diff --git a/wpiutil/src/main/java/edu/wpi/first/util/CircularBuffer.java b/wpiutil/src/main/java/edu/wpi/first/util/CircularBuffer.java
index f9129c7..729c8b1 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/CircularBuffer.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/CircularBuffer.java
@@ -4,6 +4,8 @@
 
 package edu.wpi.first.util;
 
+import java.util.Arrays;
+
 /** This is a simple circular buffer so we don't need to "bucket brigade" copy old values. */
 public class CircularBuffer {
   private double[] m_data;
@@ -21,9 +23,7 @@
    */
   public CircularBuffer(int size) {
     m_data = new double[size];
-    for (int i = 0; i < m_data.length; i++) {
-      m_data[i] = 0.0;
-    }
+    Arrays.fill(m_data, 0.0);
   }
 
   /**
@@ -31,7 +31,7 @@
    *
    * @return number of elements in buffer
    */
-  double size() {
+  public int size() {
     return m_length;
   }
 
@@ -40,7 +40,7 @@
    *
    * @return value at front of buffer
    */
-  double getFirst() {
+  public double getFirst() {
     return m_data[m_front];
   }
 
@@ -49,7 +49,7 @@
    *
    * @return value at back of buffer
    */
-  double getLast() {
+  public double getLast() {
     // If there are no elements in the buffer, do nothing
     if (m_length == 0) {
       return 0.0;
@@ -138,7 +138,7 @@
    *
    * @param size New buffer size.
    */
-  void resize(int size) {
+  public void resize(int size) {
     double[] newBuffer = new double[size];
     m_length = Math.min(m_length, size);
     for (int i = 0; i < m_length; i++) {
@@ -150,9 +150,7 @@
 
   /** Sets internal buffer contents to zero. */
   public void clear() {
-    for (int i = 0; i < m_data.length; i++) {
-      m_data[i] = 0.0;
-    }
+    Arrays.fill(m_data, 0.0);
     m_front = 0;
     m_length = 0;
   }
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/CombinedRuntimeLoader.java b/wpiutil/src/main/java/edu/wpi/first/util/CombinedRuntimeLoader.java
index 9b23144..09e739d 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/CombinedRuntimeLoader.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/CombinedRuntimeLoader.java
@@ -56,7 +56,7 @@
    * @return List of all libraries that were extracted
    * @throws IOException Thrown if resource not found or file could not be extracted
    */
-  @SuppressWarnings({"PMD.UnnecessaryCastRule", "unchecked"})
+  @SuppressWarnings("unchecked")
   public static <T> List<String> extractLibraries(Class<T> clazz, String resourceName)
       throws IOException {
     TypeReference<HashMap<String, Object>> typeRef =
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/EventVector.java b/wpiutil/src/main/java/edu/wpi/first/util/EventVector.java
new file mode 100644
index 0000000..a85379e
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/EventVector.java
@@ -0,0 +1,54 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class EventVector {
+  private ReentrantLock m_lock = new ReentrantLock();
+  private List<Integer> m_events = new ArrayList<>();
+
+  /**
+   * Adds an event to the event vector.
+   *
+   * @param handle The event to add
+   */
+  public void add(int handle) {
+    m_lock.lock();
+    try {
+      m_events.add(handle);
+    } finally {
+      m_lock.unlock();
+    }
+  }
+
+  /**
+   * Removes an event from the event vector.
+   *
+   * @param handle The event to remove
+   */
+  public void remove(int handle) {
+    m_lock.lock();
+    try {
+      m_events.removeIf(x -> x == handle);
+    } finally {
+      m_lock.unlock();
+    }
+  }
+
+  /** Wakes up all events in the event vector. */
+  public void wakeup() {
+    m_lock.lock();
+    try {
+      for (Integer eventHandle : m_events) {
+        WPIUtilJNI.setEvent(eventHandle);
+      }
+    } finally {
+      m_lock.unlock();
+    }
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/InterpolatingTreeMap.java b/wpiutil/src/main/java/edu/wpi/first/util/InterpolatingTreeMap.java
new file mode 100644
index 0000000..ade2e5a
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/InterpolatingTreeMap.java
@@ -0,0 +1,96 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util;
+
+import java.util.TreeMap;
+
+/**
+ * Interpolating Tree Maps are used to get values at points that are not defined by making a guess
+ * from points that are defined. This uses linear interpolation.
+ */
+public class InterpolatingTreeMap<K extends Number, V extends Number> {
+  private final TreeMap<K, V> m_map = new TreeMap<>();
+
+  /**
+   * Inserts a key-value pair.
+   *
+   * @param key The key.
+   * @param value The value.
+   */
+  public void put(K key, V value) {
+    m_map.put(key, value);
+  }
+
+  /**
+   * Returns the value associated with a given key.
+   *
+   * <p>If there's no matching key, the value returned will be a linear interpolation between the
+   * keys before and after the provided one.
+   *
+   * @param key The key.
+   * @return The value associated with the given key.
+   */
+  public Double get(K key) {
+    V val = m_map.get(key);
+    if (val == null) {
+      K ceilingKey = m_map.ceilingKey(key);
+      K floorKey = m_map.floorKey(key);
+
+      if (ceilingKey == null && floorKey == null) {
+        return null;
+      }
+      if (ceilingKey == null) {
+        return m_map.get(floorKey).doubleValue();
+      }
+      if (floorKey == null) {
+        return m_map.get(ceilingKey).doubleValue();
+      }
+      V floor = m_map.get(floorKey);
+      V ceiling = m_map.get(ceilingKey);
+
+      return interpolate(floor, ceiling, inverseInterpolate(ceilingKey, key, floorKey));
+    } else {
+      return val.doubleValue();
+    }
+  }
+
+  /** Clears the contents. */
+  public void clear() {
+    m_map.clear();
+  }
+
+  /**
+   * Return the value interpolated between val1 and val2 by the interpolant d.
+   *
+   * @param val1 The lower part of the interpolation range.
+   * @param val2 The upper part of the interpolation range.
+   * @param d The interpolant in the range [0, 1].
+   * @return The interpolated value.
+   */
+  private double interpolate(V val1, V val2, double d) {
+    double dydx = val2.doubleValue() - val1.doubleValue();
+    return dydx * d + val1.doubleValue();
+  }
+
+  /**
+   * Return where within interpolation range [0, 1] q is between down and up.
+   *
+   * @param up Upper part of interpolation range.
+   * @param q Query.
+   * @param down Lower part of interpolation range.
+   * @return Interpolant in range [0, 1].
+   */
+  private double inverseInterpolate(K up, K q, K down) {
+    double upperToLower = up.doubleValue() - down.doubleValue();
+    if (upperToLower <= 0) {
+      return 0.0;
+    }
+    double queryToLower = q.doubleValue() - down.doubleValue();
+    if (queryToLower <= 0) {
+      return 0.0;
+    }
+    return queryToLower / upperToLower;
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceAnnouncer.java b/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceAnnouncer.java
deleted file mode 100644
index 1c4b2ac..0000000
--- a/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceAnnouncer.java
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.util;
-
-import java.util.Map;
-
-/** Class to announce over mDNS that a service is available. */
-public class MulticastServiceAnnouncer implements AutoCloseable {
-  private final int m_handle;
-
-  /**
-   * Creates a MulticastServiceAnnouncer.
-   *
-   * @param serviceName service name
-   * @param serviceType service type
-   * @param port port
-   * @param txt txt
-   */
-  public MulticastServiceAnnouncer(
-      String serviceName, String serviceType, int port, Map<String, String> txt) {
-    String[] keys = txt.keySet().toArray(String[]::new);
-    String[] values = txt.values().toArray(String[]::new);
-    m_handle =
-        WPIUtilJNI.createMulticastServiceAnnouncer(serviceName, serviceType, port, keys, values);
-  }
-
-  @Override
-  public void close() {
-    WPIUtilJNI.freeMulticastServiceAnnouncer(m_handle);
-  }
-
-  public void start() {
-    WPIUtilJNI.startMulticastServiceAnnouncer(m_handle);
-  }
-
-  public void stop() {
-    WPIUtilJNI.stopMulticastServiceAnnouncer(m_handle);
-  }
-
-  public boolean hasImplementation() {
-    return WPIUtilJNI.getMulticastServiceAnnouncerHasImplementation(m_handle);
-  }
-}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceResolver.java b/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceResolver.java
deleted file mode 100644
index 3e331f2..0000000
--- a/wpiutil/src/main/java/edu/wpi/first/util/MulticastServiceResolver.java
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.util;
-
-/** Class to resolve a service over mDNS. */
-public class MulticastServiceResolver implements AutoCloseable {
-  private final int m_handle;
-
-  /**
-   * Creates a MulticastServiceResolver.
-   *
-   * @param serviceType service type to look for
-   */
-  public MulticastServiceResolver(String serviceType) {
-    m_handle = WPIUtilJNI.createMulticastServiceResolver(serviceType);
-  }
-
-  @Override
-  public void close() {
-    WPIUtilJNI.freeMulticastServiceResolver(m_handle);
-  }
-
-  public void start() {
-    WPIUtilJNI.startMulticastServiceResolver(m_handle);
-  }
-
-  public void stop() {
-    WPIUtilJNI.stopMulticastServiceResolver(m_handle);
-  }
-
-  public boolean hasImplementation() {
-    return WPIUtilJNI.getMulticastServiceResolverHasImplementation(m_handle);
-  }
-
-  public int getEventHandle() {
-    return WPIUtilJNI.getMulticastServiceResolverEventHandle(m_handle);
-  }
-
-  public ServiceData[] getData() {
-    return WPIUtilJNI.getMulticastServiceResolverData(m_handle);
-  }
-}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/RuntimeDetector.java b/wpiutil/src/main/java/edu/wpi/first/util/RuntimeDetector.java
index d4ad833..550339e 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/RuntimeDetector.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/RuntimeDetector.java
@@ -4,11 +4,7 @@
 
 package edu.wpi.first.util;
 
-import java.io.BufferedReader;
 import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
 
 public final class RuntimeDetector {
   private static String filePrefix;
@@ -22,6 +18,7 @@
 
     boolean intel32 = is32BitIntel();
     boolean intel64 = is64BitIntel();
+    boolean arm64 = isArm64();
 
     if (isWindows()) {
       filePrefix = "";
@@ -34,11 +31,7 @@
     } else if (isMac()) {
       filePrefix = "lib";
       fileExtension = ".dylib";
-      if (intel32) {
-        filePath = "/osx/x86";
-      } else {
-        filePath = "/osx/x86-64/";
-      }
+      filePath = "/osx/universal/";
     } else if (isLinux()) {
       filePrefix = "lib";
       fileExtension = ".so";
@@ -48,10 +41,10 @@
         filePath = "/linux/x86-64/";
       } else if (isAthena()) {
         filePath = "/linux/athena/";
-      } else if (isRaspbian()) {
-        filePath = "/linux/raspbian/";
-      } else if (isAarch64()) {
-        filePath = "/linux/aarch64bionic/";
+      } else if (isArm32()) {
+        filePath = "/linux/arm32/";
+      } else if (arm64) {
+        filePath = "/linux/arm64/";
       } else {
         filePath = "/linux/nativearm/";
       }
@@ -128,29 +121,23 @@
   }
 
   /**
-   * Check if OS is Raspbian.
+   * Check if OS is Arm32.
    *
-   * @return True if OS is Raspbian.
+   * @return True if OS is Arm32.
    */
-  public static boolean isRaspbian() {
-    try (BufferedReader reader = Files.newBufferedReader(Paths.get("/etc/os-release"))) {
-      String value = reader.readLine();
-      if (value == null) {
-        return false;
-      }
-      return value.contains("Raspbian");
-    } catch (IOException ex) {
-      return false;
-    }
+  public static boolean isArm32() {
+    String arch = System.getProperty("os.arch");
+    return "arm".equals(arch) || "arm32".equals(arch);
   }
 
   /**
-   * check if architecture is aarch64.
+   * check if architecture is Arm64.
    *
-   * @return if architecture is aarch64
+   * @return if architecture is Arm64
    */
-  public static boolean isAarch64() {
-    return "aarch64".equals(System.getProperty("os.arch"));
+  public static boolean isArm64() {
+    String arch = System.getProperty("os.arch");
+    return "aarch64".equals(arch) || "arm64".equals(arch);
   }
 
   public static boolean isLinux() {
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/RuntimeLoader.java b/wpiutil/src/main/java/edu/wpi/first/util/RuntimeLoader.java
index 942055a..f24ace3 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/RuntimeLoader.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/RuntimeLoader.java
@@ -21,7 +21,7 @@
   private static String defaultExtractionRoot;
 
   /**
-   * Gets the default extration root location (~/.wpilib/nativecache).
+   * Gets the default extraction root location (~/.wpilib/nativecache).
    *
    * @return The default extraction root location.
    */
@@ -80,7 +80,6 @@
    *
    * @throws IOException if the library fails to load
    */
-  @SuppressWarnings("PMD.PreserveStackTrace")
   public void loadLibrary() throws IOException {
     try {
       // First, try loading path
@@ -88,20 +87,20 @@
     } catch (UnsatisfiedLinkError ule) {
       // Then load the hash from the resources
       String hashName = RuntimeDetector.getHashLibraryResource(m_libraryName);
-      String resname = RuntimeDetector.getLibraryResource(m_libraryName);
+      String resName = RuntimeDetector.getLibraryResource(m_libraryName);
       try (InputStream hashIs = m_loadClass.getResourceAsStream(hashName)) {
         if (hashIs == null) {
           throw new IOException(getLoadErrorMessage(ule));
         }
-        try (Scanner scanner = new Scanner(hashIs, StandardCharsets.UTF_8.name())) {
+        try (Scanner scanner = new Scanner(hashIs, StandardCharsets.UTF_8)) {
           String hash = scanner.nextLine();
-          File jniLibrary = new File(m_extractionRoot, resname + "." + hash);
+          File jniLibrary = new File(m_extractionRoot, resName + "." + hash);
           try {
             // Try to load from an already extracted hash
             System.load(jniLibrary.getAbsolutePath());
           } catch (UnsatisfiedLinkError ule2) {
             // If extraction failed, extract
-            try (InputStream resIs = m_loadClass.getResourceAsStream(resname)) {
+            try (InputStream resIs = m_loadClass.getResourceAsStream(resName)) {
               if (resIs == null) {
                 throw new IOException(getLoadErrorMessage(ule));
               }
@@ -132,16 +131,15 @@
    *
    * @throws IOException if the library failed to load
    */
-  @SuppressWarnings({"PMD.PreserveStackTrace", "PMD.EmptyWhileStmt"})
   public void loadLibraryHashed() throws IOException {
     try {
       // First, try loading path
       System.loadLibrary(m_libraryName);
     } catch (UnsatisfiedLinkError ule) {
       // Then load the hash from the input file
-      String resname = RuntimeDetector.getLibraryResource(m_libraryName);
+      String resName = RuntimeDetector.getLibraryResource(m_libraryName);
       String hash;
-      try (InputStream is = m_loadClass.getResourceAsStream(resname)) {
+      try (InputStream is = m_loadClass.getResourceAsStream(resName)) {
         if (is == null) {
           throw new IOException(getLoadErrorMessage(ule));
         }
@@ -167,13 +165,13 @@
       if (hash == null) {
         throw new IOException("Weird Hash?");
       }
-      File jniLibrary = new File(m_extractionRoot, resname + "." + hash);
+      File jniLibrary = new File(m_extractionRoot, resName + "." + hash);
       try {
         // Try to load from an already extracted hash
         System.load(jniLibrary.getAbsolutePath());
       } catch (UnsatisfiedLinkError ule2) {
         // If extraction failed, extract
-        try (InputStream resIs = m_loadClass.getResourceAsStream(resname)) {
+        try (InputStream resIs = m_loadClass.getResourceAsStream(resName)) {
           if (resIs == null) {
             throw new IOException(getLoadErrorMessage(ule));
           }
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/ServiceData.java b/wpiutil/src/main/java/edu/wpi/first/util/ServiceData.java
deleted file mode 100644
index 0e56010..0000000
--- a/wpiutil/src/main/java/edu/wpi/first/util/ServiceData.java
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.util;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/** Service data for MulticastServiceResolver. */
-public class ServiceData {
-  /**
-   * Constructs a ServiceData.
-   *
-   * @param ipv4Address ipv4Address
-   * @param port port
-   * @param serviceName found service name
-   * @param hostName found host name
-   * @param keys txt keys
-   * @param values txt values
-   */
-  public ServiceData(
-      long ipv4Address,
-      int port,
-      String serviceName,
-      String hostName,
-      String[] keys,
-      String[] values) {
-    this.m_serviceName = serviceName;
-    this.m_hostName = hostName;
-    this.m_port = port;
-    this.m_ipv4Address = ipv4Address;
-
-    m_txt = new HashMap<>();
-
-    for (int i = 0; i < keys.length; i++) {
-      m_txt.put(keys[i], values[i]);
-    }
-  }
-
-  public Map<String, String> getTxt() {
-    return m_txt;
-  }
-
-  public String getHostName() {
-    return m_hostName;
-  }
-
-  public String getServiceName() {
-    return m_serviceName;
-  }
-
-  public int getPort() {
-    return m_port;
-  }
-
-  public long getIpv4Address() {
-    return m_ipv4Address;
-  }
-
-  private final Map<String, String> m_txt;
-  private final long m_ipv4Address;
-  private final int m_port;
-  private final String m_serviceName;
-  private final String m_hostName;
-}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/WPIUtilJNI.java b/wpiutil/src/main/java/edu/wpi/first/util/WPIUtilJNI.java
index c79f458..9929b48 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/WPIUtilJNI.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/WPIUtilJNI.java
@@ -7,7 +7,7 @@
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public final class WPIUtilJNI {
+public class WPIUtilJNI {
   static boolean libraryLoaded = false;
   static RuntimeLoader<WPIUtilJNI> loader = null;
 
@@ -54,6 +54,8 @@
     libraryLoaded = true;
   }
 
+  public static native void writeStderr(String str);
+
   public static native void enableMockTime();
 
   public static native void disableMockTime();
@@ -64,10 +66,6 @@
 
   public static native long getSystemTime();
 
-  public static native void addPortForwarder(int port, String remoteHost, int remotePort);
-
-  public static native void removePortForwarder(int port);
-
   public static native int createEvent(boolean manualReset, boolean initialState);
 
   public static native void destroyEvent(int eventHandle);
@@ -83,7 +81,7 @@
   public static native boolean releaseSemaphore(int semHandle, int releaseCount);
 
   /**
-   * Waits for an handle to be signaled.
+   * Waits for a handle to be signaled.
    *
    * @param handle handle to wait on
    * @throws InterruptedException on failure (e.g. object was destroyed)
@@ -91,7 +89,7 @@
   public static native void waitForObject(int handle) throws InterruptedException;
 
   /**
-   * Waits for an handle to be signaled, with timeout.
+   * Waits for a handle to be signaled, with timeout.
    *
    * @param handle handle to wait on
    * @param timeout timeout in seconds
@@ -126,29 +124,4 @@
    */
   public static native int[] waitForObjectsTimeout(int[] handles, double timeout)
       throws InterruptedException;
-
-  public static native int createMulticastServiceAnnouncer(
-      String serviceName, String serviceType, int port, String[] keys, String[] values);
-
-  public static native void freeMulticastServiceAnnouncer(int handle);
-
-  public static native void startMulticastServiceAnnouncer(int handle);
-
-  public static native void stopMulticastServiceAnnouncer(int handle);
-
-  public static native boolean getMulticastServiceAnnouncerHasImplementation(int handle);
-
-  public static native int createMulticastServiceResolver(String serviceType);
-
-  public static native void freeMulticastServiceResolver(int handle);
-
-  public static native void startMulticastServiceResolver(int handle);
-
-  public static native void stopMulticastServiceResolver(int handle);
-
-  public static native boolean getMulticastServiceResolverHasImplementation(int handle);
-
-  public static native int getMulticastServiceResolverEventHandle(int handle);
-
-  public static native ServiceData[] getMulticastServiceResolverData(int handle);
 }
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/concurrent/Semaphore.java b/wpiutil/src/main/java/edu/wpi/first/util/concurrent/Semaphore.java
index 4e9e85f..66c28a2 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/concurrent/Semaphore.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/concurrent/Semaphore.java
@@ -18,7 +18,7 @@
    * Constructor.
    *
    * @param initialCount initial value for the semaphore's internal counter
-   * @param maximumCount maximum value for the samephore's internal counter
+   * @param maximumCount maximum value for the semaphore's internal counter
    */
   public Semaphore(int initialCount, int maximumCount) {
     m_handle = WPIUtilJNI.createSemaphore(initialCount, maximumCount);
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanArrayLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanArrayLogEntry.java
new file mode 100644
index 0000000..718d460
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanArrayLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log array of boolean values. */
+public class BooleanArrayLogEntry extends DataLogEntry {
+  public static final String kDataType = "boolean[]";
+
+  public BooleanArrayLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public BooleanArrayLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public BooleanArrayLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public BooleanArrayLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(boolean[] value, long timestamp) {
+    m_log.appendBooleanArray(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(boolean[] value) {
+    m_log.appendBooleanArray(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanLogEntry.java
new file mode 100644
index 0000000..503b83b
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/BooleanLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log boolean values. */
+public class BooleanLogEntry extends DataLogEntry {
+  public static final String kDataType = "boolean";
+
+  public BooleanLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public BooleanLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public BooleanLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public BooleanLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(boolean value, long timestamp) {
+    m_log.appendBoolean(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(boolean value) {
+    m_log.appendBoolean(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLog.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLog.java
new file mode 100644
index 0000000..784b8d6
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLog.java
@@ -0,0 +1,252 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/**
+ * A data log. The log file is created immediately upon construction with a temporary filename. The
+ * file may be renamed at any time using the setFilename() function.
+ *
+ * <p>The data log is periodically flushed to disk. It can also be explicitly flushed to disk by
+ * using the flush() function.
+ *
+ * <p>The finish() function is needed only to indicate in the log that a particular entry is no
+ * longer being used (it releases the name to ID mapping). The finish() function is not required to
+ * be called for data to be flushed to disk; entries in the log are written as append() calls are
+ * being made. In fact, finish() does not need to be called at all.
+ *
+ * <p>DataLog calls are thread safe. DataLog uses a typical multiple-supplier, single-consumer
+ * setup. Writes to the log are atomic, but there is no guaranteed order in the log when multiple
+ * threads are writing to it; whichever thread grabs the write mutex first will get written first.
+ * For this reason (as well as the fact that timestamps can be set to arbitrary values), records in
+ * the log are not guaranteed to be sorted by timestamp.
+ */
+public final class DataLog implements AutoCloseable {
+  /**
+   * Construct a new Data Log. The log will be initially created with a temporary filename.
+   *
+   * @param dir directory to store the log
+   * @param filename filename to use; if none provided, a random filename is generated of the form
+   *     "wpilog_{}.wpilog"
+   * @param period time between automatic flushes to disk, in seconds; this is a time/storage
+   *     tradeoff
+   * @param extraHeader extra header data
+   */
+  public DataLog(String dir, String filename, double period, String extraHeader) {
+    m_impl = DataLogJNI.create(dir, filename, period, extraHeader);
+  }
+
+  /**
+   * Construct a new Data Log. The log will be initially created with a temporary filename.
+   *
+   * @param dir directory to store the log
+   * @param filename filename to use; if none provided, a random filename is generated of the form
+   *     "wpilog_{}.wpilog"
+   * @param period time between automatic flushes to disk, in seconds; this is a time/storage
+   *     tradeoff
+   */
+  public DataLog(String dir, String filename, double period) {
+    this(dir, filename, period, "");
+  }
+
+  /**
+   * Construct a new Data Log. The log will be initially created with a temporary filename.
+   *
+   * @param dir directory to store the log
+   * @param filename filename to use; if none provided, a random filename is generated of the form
+   *     "wpilog_{}.wpilog"
+   */
+  public DataLog(String dir, String filename) {
+    this(dir, filename, 0.25);
+  }
+
+  /**
+   * Construct a new Data Log. The log will be initially created with a temporary filename.
+   *
+   * @param dir directory to store the log
+   */
+  public DataLog(String dir) {
+    this(dir, "", 0.25);
+  }
+
+  /** Construct a new Data Log. The log will be initially created with a temporary filename. */
+  public DataLog() {
+    this("");
+  }
+
+  /**
+   * Change log filename.
+   *
+   * @param filename filename
+   */
+  public void setFilename(String filename) {
+    DataLogJNI.setFilename(m_impl, filename);
+  }
+
+  /** Explicitly flushes the log data to disk. */
+  public void flush() {
+    DataLogJNI.flush(m_impl);
+  }
+
+  /**
+   * Pauses appending of data records to the log. While paused, no data records are saved (e.g.
+   * AppendX is a no-op). Has no effect on entry starts / finishes / metadata changes.
+   */
+  public void pause() {
+    DataLogJNI.pause(m_impl);
+  }
+
+  /** Resumes appending of data records to the log. */
+  public void resume() {
+    DataLogJNI.resume(m_impl);
+  }
+
+  /**
+   * Start an entry. Duplicate names are allowed (with the same type), and result in the same index
+   * being returned (start/finish are reference counted). A duplicate name with a different type
+   * will result in an error message being printed to the console and 0 being returned (which will
+   * be ignored by the append functions).
+   *
+   * @param name Name
+   * @param type Data type
+   * @param metadata Initial metadata (e.g. data properties)
+   * @param timestamp Time stamp (0 to indicate now)
+   * @return Entry index
+   */
+  public int start(String name, String type, String metadata, long timestamp) {
+    return DataLogJNI.start(m_impl, name, type, metadata, timestamp);
+  }
+
+  /**
+   * Start an entry. Duplicate names are allowed (with the same type), and result in the same index
+   * being returned (start/finish are reference counted). A duplicate name with a different type
+   * will result in an error message being printed to the console and 0 being returned (which will
+   * be ignored by the append functions).
+   *
+   * @param name Name
+   * @param type Data type
+   * @param metadata Initial metadata (e.g. data properties)
+   * @return Entry index
+   */
+  public int start(String name, String type, String metadata) {
+    return start(name, type, metadata, 0);
+  }
+
+  /**
+   * Start an entry. Duplicate names are allowed (with the same type), and result in the same index
+   * being returned (start/finish are reference counted). A duplicate name with a different type
+   * will result in an error message being printed to the console and 0 being returned (which will
+   * be ignored by the append functions).
+   *
+   * @param name Name
+   * @param type Data type
+   * @return Entry index
+   */
+  public int start(String name, String type) {
+    return start(name, type, "");
+  }
+
+  /**
+   * Finish an entry.
+   *
+   * @param entry Entry index
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void finish(int entry, long timestamp) {
+    DataLogJNI.finish(m_impl, entry, timestamp);
+  }
+
+  /**
+   * Finish an entry.
+   *
+   * @param entry Entry index
+   */
+  public void finish(int entry) {
+    finish(entry, 0);
+  }
+
+  /**
+   * Updates the metadata for an entry.
+   *
+   * @param entry Entry index
+   * @param metadata New metadata for the entry
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void setMetadata(int entry, String metadata, long timestamp) {
+    DataLogJNI.setMetadata(m_impl, entry, metadata, timestamp);
+  }
+
+  /**
+   * Updates the metadata for an entry.
+   *
+   * @param entry Entry index
+   * @param metadata New metadata for the entry
+   */
+  public void setMetadata(int entry, String metadata) {
+    setMetadata(entry, metadata, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param entry Entry index, as returned by Start()
+   * @param data Data to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void appendRaw(int entry, byte[] data, long timestamp) {
+    DataLogJNI.appendRaw(m_impl, entry, data, timestamp);
+  }
+
+  @Override
+  public void close() {
+    DataLogJNI.close(m_impl);
+    m_impl = 0;
+  }
+
+  public void appendBoolean(int entry, boolean value, long timestamp) {
+    DataLogJNI.appendBoolean(m_impl, entry, value, timestamp);
+  }
+
+  public void appendInteger(int entry, long value, long timestamp) {
+    DataLogJNI.appendInteger(m_impl, entry, value, timestamp);
+  }
+
+  public void appendFloat(int entry, float value, long timestamp) {
+    DataLogJNI.appendFloat(m_impl, entry, value, timestamp);
+  }
+
+  public void appendDouble(int entry, double value, long timestamp) {
+    DataLogJNI.appendDouble(m_impl, entry, value, timestamp);
+  }
+
+  public void appendString(int entry, String value, long timestamp) {
+    DataLogJNI.appendString(m_impl, entry, value, timestamp);
+  }
+
+  public void appendBooleanArray(int entry, boolean[] arr, long timestamp) {
+    DataLogJNI.appendBooleanArray(m_impl, entry, arr, timestamp);
+  }
+
+  public void appendIntegerArray(int entry, long[] arr, long timestamp) {
+    DataLogJNI.appendIntegerArray(m_impl, entry, arr, timestamp);
+  }
+
+  public void appendFloatArray(int entry, float[] arr, long timestamp) {
+    DataLogJNI.appendFloatArray(m_impl, entry, arr, timestamp);
+  }
+
+  public void appendDoubleArray(int entry, double[] arr, long timestamp) {
+    DataLogJNI.appendDoubleArray(m_impl, entry, arr, timestamp);
+  }
+
+  public void appendStringArray(int entry, String[] arr, long timestamp) {
+    DataLogJNI.appendStringArray(m_impl, entry, arr, timestamp);
+  }
+
+  public long getImpl() {
+    return m_impl;
+  }
+
+  private long m_impl;
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogEntry.java
new file mode 100644
index 0000000..4beaff2
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogEntry.java
@@ -0,0 +1,57 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log entry base class. */
+public class DataLogEntry {
+  protected DataLogEntry(DataLog log, String name, String type, String metadata, long timestamp) {
+    m_log = log;
+    m_entry = log.start(name, type, metadata, timestamp);
+  }
+
+  protected DataLogEntry(DataLog log, String name, String type, String metadata) {
+    this(log, name, type, metadata, 0);
+  }
+
+  protected DataLogEntry(DataLog log, String name, String type) {
+    this(log, name, type, "");
+  }
+
+  /**
+   * Updates the metadata for the entry.
+   *
+   * @param metadata New metadata for the entry
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void setMetadata(String metadata, long timestamp) {
+    m_log.setMetadata(m_entry, metadata, timestamp);
+  }
+
+  /**
+   * Updates the metadata for the entry.
+   *
+   * @param metadata New metadata for the entry
+   */
+  public void setMetadata(String metadata) {
+    setMetadata(metadata, 0);
+  }
+
+  /**
+   * Finishes the entry.
+   *
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void finish(long timestamp) {
+    m_log.finish(m_entry, timestamp);
+  }
+
+  /** Finishes the entry. */
+  public void finish() {
+    finish(0);
+  }
+
+  protected final DataLog m_log;
+  protected final int m_entry;
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogIterator.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogIterator.java
new file mode 100644
index 0000000..3f1d66e
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogIterator.java
@@ -0,0 +1,46 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.function.Consumer;
+
+/** DataLogReader iterator. */
+public class DataLogIterator implements Iterator<DataLogRecord> {
+  DataLogIterator(DataLogReader reader, int pos) {
+    m_reader = reader;
+    m_pos = pos;
+  }
+
+  @Override
+  public void forEachRemaining(Consumer<? super DataLogRecord> action) {
+    int size = m_reader.size();
+    for (; m_pos < size; m_pos = m_reader.getNextRecord(m_pos)) {
+      DataLogRecord record;
+      try {
+        record = m_reader.getRecord(m_pos);
+      } catch (NoSuchElementException ex) {
+        break;
+      }
+      action.accept(record);
+    }
+  }
+
+  @Override
+  public boolean hasNext() {
+    return (m_pos + 16) <= m_reader.size();
+  }
+
+  @Override
+  public DataLogRecord next() {
+    DataLogRecord record = m_reader.getRecord(m_pos);
+    m_pos = m_reader.getNextRecord(m_pos);
+    return record;
+  }
+
+  private final DataLogReader m_reader;
+  private int m_pos;
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogJNI.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogJNI.java
new file mode 100644
index 0000000..724b3d9
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogJNI.java
@@ -0,0 +1,49 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+import edu.wpi.first.util.WPIUtilJNI;
+
+public class DataLogJNI extends WPIUtilJNI {
+  static native long create(String dir, String filename, double period, String extraHeader);
+
+  static native void setFilename(long impl, String filename);
+
+  static native void flush(long impl);
+
+  static native void pause(long impl);
+
+  static native void resume(long impl);
+
+  static native int start(long impl, String name, String type, String metadata, long timestamp);
+
+  static native void finish(long impl, int entry, long timestamp);
+
+  static native void setMetadata(long impl, int entry, String metadata, long timestamp);
+
+  static native void close(long impl);
+
+  static native void appendRaw(long impl, int entry, byte[] data, long timestamp);
+
+  static native void appendBoolean(long impl, int entry, boolean value, long timestamp);
+
+  static native void appendInteger(long impl, int entry, long value, long timestamp);
+
+  static native void appendFloat(long impl, int entry, float value, long timestamp);
+
+  static native void appendDouble(long impl, int entry, double value, long timestamp);
+
+  static native void appendString(long impl, int entry, String value, long timestamp);
+
+  static native void appendBooleanArray(long impl, int entry, boolean[] value, long timestamp);
+
+  static native void appendIntegerArray(long impl, int entry, long[] value, long timestamp);
+
+  static native void appendFloatArray(long impl, int entry, float[] value, long timestamp);
+
+  static native void appendDoubleArray(long impl, int entry, double[] value, long timestamp);
+
+  static native void appendStringArray(long impl, int entry, String[] value, long timestamp);
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogReader.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogReader.java
new file mode 100644
index 0000000..55eabf3
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogReader.java
@@ -0,0 +1,154 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.util.NoSuchElementException;
+import java.util.function.Consumer;
+
+/** Data log reader (reads logs written by the DataLog class). */
+public class DataLogReader implements Iterable<DataLogRecord> {
+  /**
+   * Constructs from a byte buffer.
+   *
+   * @param buffer byte buffer
+   */
+  public DataLogReader(ByteBuffer buffer) {
+    m_buf = buffer;
+    m_buf.order(ByteOrder.LITTLE_ENDIAN);
+  }
+
+  /**
+   * Constructs from a file.
+   *
+   * @param filename filename
+   * @throws IOException if unable to open/read file
+   */
+  public DataLogReader(String filename) throws IOException {
+    RandomAccessFile f = new RandomAccessFile(filename, "r");
+    FileChannel channel = f.getChannel();
+    m_buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
+    m_buf.order(ByteOrder.LITTLE_ENDIAN);
+    channel.close();
+    f.close();
+  }
+
+  /**
+   * Returns true if the data log is valid (e.g. has a valid header).
+   *
+   * @return True if valid, false otherwise
+   */
+  public boolean isValid() {
+    return m_buf.remaining() >= 12
+        && m_buf.get(0) == 'W'
+        && m_buf.get(1) == 'P'
+        && m_buf.get(2) == 'I'
+        && m_buf.get(3) == 'L'
+        && m_buf.get(4) == 'O'
+        && m_buf.get(5) == 'G'
+        && m_buf.getShort(6) >= 0x0100;
+  }
+
+  /**
+   * Gets the data log version. Returns 0 if data log is invalid.
+   *
+   * @return Version number; most significant byte is major, least significant is minor (so version
+   *     1.0 will be 0x0100)
+   */
+  public short getVersion() {
+    if (m_buf.remaining() < 12) {
+      return 0;
+    }
+    return m_buf.getShort(6);
+  }
+
+  /**
+   * Gets the extra header data.
+   *
+   * @return Extra header data
+   */
+  public String getExtraHeader() {
+    ByteBuffer buf = m_buf.duplicate();
+    buf.order(ByteOrder.LITTLE_ENDIAN);
+    buf.position(8);
+    int size = buf.getInt();
+    byte[] arr = new byte[size];
+    buf.get(arr);
+    return new String(arr, StandardCharsets.UTF_8);
+  }
+
+  @Override
+  public void forEach(Consumer<? super DataLogRecord> action) {
+    int size = m_buf.remaining();
+    for (int pos = 12 + m_buf.getInt(8); pos < size; pos = getNextRecord(pos)) {
+      DataLogRecord record;
+      try {
+        record = getRecord(pos);
+      } catch (NoSuchElementException ex) {
+        break;
+      }
+      action.accept(record);
+    }
+  }
+
+  @Override
+  public DataLogIterator iterator() {
+    return new DataLogIterator(this, 12 + m_buf.getInt(8));
+  }
+
+  private long readVarInt(int pos, int len) {
+    long val = 0;
+    for (int i = 0; i < len; i++) {
+      val |= ((long) (m_buf.get(pos + i) & 0xff)) << (i * 8);
+    }
+    return val;
+  }
+
+  DataLogRecord getRecord(int pos) {
+    try {
+      int lenbyte = m_buf.get(pos) & 0xff;
+      int entryLen = (lenbyte & 0x3) + 1;
+      int sizeLen = ((lenbyte >> 2) & 0x3) + 1;
+      int timestampLen = ((lenbyte >> 4) & 0x7) + 1;
+      int headerLen = 1 + entryLen + sizeLen + timestampLen;
+      int entry = (int) readVarInt(pos + 1, entryLen);
+      int size = (int) readVarInt(pos + 1 + entryLen, sizeLen);
+      long timestamp = readVarInt(pos + 1 + entryLen + sizeLen, timestampLen);
+      // build a slice of the data contents
+      ByteBuffer data = m_buf.duplicate();
+      data.position(pos + headerLen);
+      data.limit(pos + headerLen + size);
+      return new DataLogRecord(entry, timestamp, data.slice());
+    } catch (BufferUnderflowException | IndexOutOfBoundsException ex) {
+      throw new NoSuchElementException();
+    }
+  }
+
+  int getNextRecord(int pos) {
+    int lenbyte = m_buf.get(pos) & 0xff;
+    int entryLen = (lenbyte & 0x3) + 1;
+    int sizeLen = ((lenbyte >> 2) & 0x3) + 1;
+    int timestampLen = ((lenbyte >> 4) & 0x7) + 1;
+    int headerLen = 1 + entryLen + sizeLen + timestampLen;
+
+    int size = 0;
+    for (int i = 0; i < sizeLen; i++) {
+      size |= (m_buf.get(pos + 1 + entryLen + i) & 0xff) << (i * 8);
+    }
+    return pos + headerLen + size;
+  }
+
+  int size() {
+    return m_buf.remaining();
+  }
+
+  private final ByteBuffer m_buf;
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogRecord.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogRecord.java
new file mode 100644
index 0000000..5e3965b
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DataLogRecord.java
@@ -0,0 +1,430 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+import java.nio.LongBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.InputMismatchException;
+
+/**
+ * A record in the data log. May represent either a control record (entry == 0) or a data record.
+ * Used only for reading (e.g. with DataLogReader).
+ */
+public class DataLogRecord {
+  private static final int kControlStart = 0;
+  private static final int kControlFinish = 1;
+  private static final int kControlSetMetadata = 2;
+
+  DataLogRecord(int entry, long timestamp, ByteBuffer data) {
+    m_entry = entry;
+    m_timestamp = timestamp;
+    m_data = data;
+    m_data.order(ByteOrder.LITTLE_ENDIAN);
+  }
+
+  /**
+   * Gets the entry ID.
+   *
+   * @return entry ID
+   */
+  public int getEntry() {
+    return m_entry;
+  }
+
+  /**
+   * Gets the record timestamp.
+   *
+   * @return Timestamp, in integer microseconds
+   */
+  public long getTimestamp() {
+    return m_timestamp;
+  }
+
+  /**
+   * Gets the size of the raw data.
+   *
+   * @return size
+   */
+  public int getSize() {
+    return m_data.remaining();
+  }
+
+  /**
+   * Gets the raw data. Use the GetX functions to decode based on the data type in the entry's start
+   * record.
+   *
+   * @return byte array
+   */
+  public byte[] getRaw() {
+    ByteBuffer buf = getRawBuffer();
+    byte[] arr = new byte[buf.remaining()];
+    buf.get(arr);
+    return arr;
+  }
+
+  /**
+   * Gets the raw data. Use the GetX functions to decode based on the data type in the entry's start
+   * record.
+   *
+   * @return byte buffer
+   */
+  public ByteBuffer getRawBuffer() {
+    ByteBuffer buf = m_data.duplicate();
+    buf.order(ByteOrder.LITTLE_ENDIAN);
+    return buf;
+  }
+
+  /**
+   * Returns true if the record is a control record.
+   *
+   * @return True if control record, false if normal data record.
+   */
+  public boolean isControl() {
+    return m_entry == 0;
+  }
+
+  /**
+   * Returns true if the record is a start control record. Use GetStartData() to decode the
+   * contents.
+   *
+   * @return True if start control record, false otherwise.
+   */
+  public boolean isStart() {
+    return m_entry == 0 && m_data.remaining() >= 17 && m_data.get(0) == kControlStart;
+  }
+
+  /**
+   * Returns true if the record is a finish control record. Use GetFinishEntry() to decode the
+   * contents.
+   *
+   * @return True if finish control record, false otherwise.
+   */
+  public boolean isFinish() {
+    return m_entry == 0 && m_data.remaining() == 5 && m_data.get(0) == kControlFinish;
+  }
+
+  /**
+   * Returns true if the record is a set metadata control record. Use GetSetMetadataData() to decode
+   * the contents.
+   *
+   * @return True if set metadata control record, false otherwise.
+   */
+  public boolean isSetMetadata() {
+    return m_entry == 0 && m_data.remaining() >= 9 && m_data.get(0) == kControlSetMetadata;
+  }
+
+  /**
+   * Data contained in a start control record as created by DataLog.start() when writing the log.
+   * This can be read by calling getStartData().
+   */
+  @SuppressWarnings("MemberName")
+  public static class StartRecordData {
+    StartRecordData(int entry, String name, String type, String metadata) {
+      this.entry = entry;
+      this.name = name;
+      this.type = type;
+      this.metadata = metadata;
+    }
+
+    /** Entry ID; this will be used for this entry in future records. */
+    public final int entry;
+
+    /** Entry name. */
+    public final String name;
+
+    /** Type of the stored data for this entry, as a string, e.g. "double". */
+    public final String type;
+
+    /** Initial metadata. */
+    public final String metadata;
+  }
+
+  /**
+   * Decodes a start control record.
+   *
+   * @return start record decoded data
+   * @throws InputMismatchException on error
+   */
+  public StartRecordData getStartData() {
+    if (!isStart()) {
+      throw new InputMismatchException("not a start record");
+    }
+    ByteBuffer buf = getRawBuffer();
+    buf.position(1); // skip over control type
+    int entry = buf.getInt();
+    String name = readInnerString(buf);
+    String type = readInnerString(buf);
+    String metadata = readInnerString(buf);
+    return new StartRecordData(entry, name, type, metadata);
+  }
+
+  /**
+   * Data contained in a set metadata control record as created by DataLog.setMetadata(). This can
+   * be read by calling getSetMetadataData().
+   */
+  @SuppressWarnings("MemberName")
+  public static class MetadataRecordData {
+    MetadataRecordData(int entry, String metadata) {
+      this.entry = entry;
+      this.metadata = metadata;
+    }
+
+    /** Entry ID. */
+    public final int entry;
+
+    /** New metadata for the entry. */
+    public final String metadata;
+  }
+
+  /**
+   * Decodes a finish control record.
+   *
+   * @return finish record entry ID
+   * @throws InputMismatchException on error
+   */
+  public int getFinishEntry() {
+    if (!isFinish()) {
+      throw new InputMismatchException("not a finish record");
+    }
+    return m_data.getInt(1);
+  }
+
+  /**
+   * Decodes a set metadata control record.
+   *
+   * @return set metadata record decoded data
+   * @throws InputMismatchException on error
+   */
+  public MetadataRecordData getSetMetadataData() {
+    if (!isSetMetadata()) {
+      throw new InputMismatchException("not a set metadata record");
+    }
+    ByteBuffer buf = getRawBuffer();
+    buf.position(1); // skip over control type
+    int entry = buf.getInt();
+    String metadata = readInnerString(buf);
+    return new MetadataRecordData(entry, metadata);
+  }
+
+  /**
+   * Decodes a data record as a boolean. Note if the data type (as indicated in the corresponding
+   * start control record for this entry) is not "boolean", invalid results may be returned.
+   *
+   * @return boolean value
+   * @throws InputMismatchException on error
+   */
+  public boolean getBoolean() {
+    try {
+      return m_data.get(0) != 0;
+    } catch (IndexOutOfBoundsException ex) {
+      throw new InputMismatchException();
+    }
+  }
+
+  /**
+   * Decodes a data record as an integer. Note if the data type (as indicated in the corresponding
+   * start control record for this entry) is not "int64", invalid results may be returned.
+   *
+   * @return integer value
+   * @throws InputMismatchException on error
+   */
+  public long getInteger() {
+    try {
+      return m_data.getLong(0);
+    } catch (BufferUnderflowException | IndexOutOfBoundsException ex) {
+      throw new InputMismatchException();
+    }
+  }
+
+  /**
+   * Decodes a data record as a float. Note if the data type (as indicated in the corresponding
+   * start control record for this entry) is not "float", invalid results may be returned.
+   *
+   * @return float value
+   * @throws InputMismatchException on error
+   */
+  public float getFloat() {
+    try {
+      return m_data.getFloat(0);
+    } catch (BufferUnderflowException | IndexOutOfBoundsException ex) {
+      throw new InputMismatchException();
+    }
+  }
+
+  /**
+   * Decodes a data record as a double. Note if the data type (as indicated in the corresponding
+   * start control record for this entry) is not "double", invalid results may be returned.
+   *
+   * @return double value
+   * @throws InputMismatchException on error
+   */
+  public double getDouble() {
+    try {
+      return m_data.getDouble(0);
+    } catch (BufferUnderflowException | IndexOutOfBoundsException ex) {
+      throw new InputMismatchException();
+    }
+  }
+
+  /**
+   * Decodes a data record as a string. Note if the data type (as indicated in the corresponding
+   * start control record for this entry) is not "string", invalid results may be returned.
+   *
+   * @return string value
+   */
+  public String getString() {
+    return new String(getRaw(), StandardCharsets.UTF_8);
+  }
+
+  /**
+   * Decodes a data record as a boolean array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "boolean[]", invalid results may be
+   * returned.
+   *
+   * @return boolean array
+   */
+  public boolean[] getBooleanArray() {
+    boolean[] arr = new boolean[m_data.remaining()];
+    for (int i = 0; i < m_data.remaining(); i++) {
+      arr[i] = m_data.get(i) != 0;
+    }
+    return arr;
+  }
+
+  /**
+   * Decodes a data record as an integer array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "int64[]", invalid results may be
+   * returned.
+   *
+   * @return integer array
+   * @throws InputMismatchException on error
+   */
+  public long[] getIntegerArray() {
+    LongBuffer buf = getIntegerBuffer();
+    long[] arr = new long[buf.remaining()];
+    buf.get(arr);
+    return arr;
+  }
+
+  /**
+   * Decodes a data record as an integer array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "int64[]", invalid results may be
+   * returned.
+   *
+   * @return integer buffer
+   * @throws InputMismatchException on error
+   */
+  public LongBuffer getIntegerBuffer() {
+    if ((m_data.limit() % 8) != 0) {
+      throw new InputMismatchException("data size is not a multiple of 8");
+    }
+    return m_data.asLongBuffer();
+  }
+
+  /**
+   * Decodes a data record as a float array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "float[]", invalid results may be
+   * returned.
+   *
+   * @return float array
+   * @throws InputMismatchException on error
+   */
+  public float[] getFloatArray() {
+    FloatBuffer buf = getFloatBuffer();
+    float[] arr = new float[buf.remaining()];
+    buf.get(arr);
+    return arr;
+  }
+
+  /**
+   * Decodes a data record as a float array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "float[]", invalid results may be
+   * returned.
+   *
+   * @return float buffer
+   * @throws InputMismatchException on error
+   */
+  public FloatBuffer getFloatBuffer() {
+    if ((m_data.limit() % 4) != 0) {
+      throw new InputMismatchException("data size is not a multiple of 4");
+    }
+    return m_data.asFloatBuffer();
+  }
+
+  /**
+   * Decodes a data record as a double array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "double[]", invalid results may be
+   * returned.
+   *
+   * @return double array
+   * @throws InputMismatchException on error
+   */
+  public double[] getDoubleArray() {
+    DoubleBuffer buf = getDoubleBuffer();
+    double[] arr = new double[buf.remaining()];
+    buf.get(arr);
+    return arr;
+  }
+
+  /**
+   * Decodes a data record as a double array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "double[]", invalid results may be
+   * returned.
+   *
+   * @return double buffer
+   * @throws InputMismatchException on error
+   */
+  public DoubleBuffer getDoubleBuffer() {
+    if ((m_data.limit() % 8) != 0) {
+      throw new InputMismatchException("data size is not a multiple of 8");
+    }
+    return m_data.asDoubleBuffer();
+  }
+
+  /**
+   * Decodes a data record as a string array. Note if the data type (as indicated in the
+   * corresponding start control record for this entry) is not "string[]", invalid results may be
+   * returned.
+   *
+   * @return string array
+   * @throws InputMismatchException on error
+   */
+  public String[] getStringArray() {
+    ByteBuffer buf = getRawBuffer();
+    try {
+      int size = buf.getInt();
+      // sanity check size
+      if (size > (buf.remaining() / 4)) {
+        throw new InputMismatchException("invalid size");
+      }
+      String[] arr = new String[size];
+      for (int i = 0; i < size; i++) {
+        arr[i] = readInnerString(buf);
+      }
+      return arr;
+    } catch (BufferUnderflowException | IndexOutOfBoundsException ex) {
+      throw new InputMismatchException();
+    }
+  }
+
+  private String readInnerString(ByteBuffer buf) {
+    int size = buf.getInt();
+    if (size > buf.remaining()) {
+      throw new InputMismatchException("invalid string size");
+    }
+    byte[] arr = new byte[size];
+    buf.get(arr);
+    return new String(arr, StandardCharsets.UTF_8);
+  }
+
+  private final int m_entry;
+  private final long m_timestamp;
+  private final ByteBuffer m_data;
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleArrayLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleArrayLogEntry.java
new file mode 100644
index 0000000..67ef8c3
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleArrayLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log array of double values. */
+public class DoubleArrayLogEntry extends DataLogEntry {
+  public static final String kDataType = "double[]";
+
+  public DoubleArrayLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public DoubleArrayLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public DoubleArrayLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public DoubleArrayLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(double[] value, long timestamp) {
+    m_log.appendDoubleArray(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(double[] value) {
+    m_log.appendDoubleArray(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleLogEntry.java
new file mode 100644
index 0000000..f16c27e
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/DoubleLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log double values. */
+public class DoubleLogEntry extends DataLogEntry {
+  public static final String kDataType = "double";
+
+  public DoubleLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public DoubleLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public DoubleLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public DoubleLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(double value, long timestamp) {
+    m_log.appendDouble(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(double value) {
+    m_log.appendDouble(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatArrayLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatArrayLogEntry.java
new file mode 100644
index 0000000..3a0b7e0
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatArrayLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log array of float values. */
+public class FloatArrayLogEntry extends DataLogEntry {
+  public static final String kDataType = "float[]";
+
+  public FloatArrayLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public FloatArrayLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public FloatArrayLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public FloatArrayLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(float[] value, long timestamp) {
+    m_log.appendFloatArray(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(float[] value) {
+    m_log.appendFloatArray(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatLogEntry.java
new file mode 100644
index 0000000..28adc34
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/FloatLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log float values. */
+public class FloatLogEntry extends DataLogEntry {
+  public static final String kDataType = "float";
+
+  public FloatLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public FloatLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public FloatLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public FloatLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(float value, long timestamp) {
+    m_log.appendFloat(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(float value) {
+    m_log.appendFloat(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerArrayLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerArrayLogEntry.java
new file mode 100644
index 0000000..2cffc8d
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerArrayLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log array of integer values. */
+public class IntegerArrayLogEntry extends DataLogEntry {
+  public static final String kDataType = "int64[]";
+
+  public IntegerArrayLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public IntegerArrayLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public IntegerArrayLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public IntegerArrayLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(long[] value, long timestamp) {
+    m_log.appendIntegerArray(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(long[] value) {
+    m_log.appendIntegerArray(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerLogEntry.java
new file mode 100644
index 0000000..142ca5d
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/IntegerLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log integer values. */
+public class IntegerLogEntry extends DataLogEntry {
+  public static final String kDataType = "int64";
+
+  public IntegerLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public IntegerLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public IntegerLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public IntegerLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(long value, long timestamp) {
+    m_log.appendInteger(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(long value) {
+    m_log.appendInteger(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/RawLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/RawLogEntry.java
new file mode 100644
index 0000000..160f734
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/RawLogEntry.java
@@ -0,0 +1,53 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log raw byte array values. */
+public class RawLogEntry extends DataLogEntry {
+  public static final String kDataType = "raw";
+
+  public RawLogEntry(DataLog log, String name, String metadata, String type, long timestamp) {
+    super(log, name, type, metadata, timestamp);
+  }
+
+  public RawLogEntry(DataLog log, String name, String metadata, String type) {
+    this(log, name, metadata, type, 0);
+  }
+
+  public RawLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    this(log, name, metadata, kDataType, timestamp);
+  }
+
+  public RawLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public RawLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public RawLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(byte[] value, long timestamp) {
+    m_log.appendRaw(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(byte[] value) {
+    m_log.appendRaw(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringArrayLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringArrayLogEntry.java
new file mode 100644
index 0000000..37bdeb1
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringArrayLogEntry.java
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log array of string values. */
+public class StringArrayLogEntry extends DataLogEntry {
+  public static final String kDataType = "string[]";
+
+  public StringArrayLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    super(log, name, kDataType, metadata, timestamp);
+  }
+
+  public StringArrayLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public StringArrayLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public StringArrayLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(String[] value, long timestamp) {
+    m_log.appendStringArray(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(String[] value) {
+    m_log.appendStringArray(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringLogEntry.java b/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringLogEntry.java
new file mode 100644
index 0000000..0722dc0
--- /dev/null
+++ b/wpiutil/src/main/java/edu/wpi/first/util/datalog/StringLogEntry.java
@@ -0,0 +1,53 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util.datalog;
+
+/** Log string values. */
+public class StringLogEntry extends DataLogEntry {
+  public static final String kDataType = "string";
+
+  public StringLogEntry(DataLog log, String name, String metadata, String type, long timestamp) {
+    super(log, name, type, metadata, timestamp);
+  }
+
+  public StringLogEntry(DataLog log, String name, String metadata, String type) {
+    this(log, name, metadata, type, 0);
+  }
+
+  public StringLogEntry(DataLog log, String name, String metadata, long timestamp) {
+    this(log, name, metadata, kDataType, timestamp);
+  }
+
+  public StringLogEntry(DataLog log, String name, String metadata) {
+    this(log, name, metadata, 0);
+  }
+
+  public StringLogEntry(DataLog log, String name, long timestamp) {
+    this(log, name, "", timestamp);
+  }
+
+  public StringLogEntry(DataLog log, String name) {
+    this(log, name, 0);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (0 to indicate now)
+   */
+  public void append(String value, long timestamp) {
+    m_log.appendString(m_entry, value, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   */
+  public void append(String value) {
+    m_log.appendString(m_entry, value, 0);
+  }
+}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/function/BooleanConsumer.java b/wpiutil/src/main/java/edu/wpi/first/util/function/BooleanConsumer.java
index 98fd6a2..5c357e8 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/function/BooleanConsumer.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/function/BooleanConsumer.java
@@ -7,7 +7,7 @@
 /**
  * Represents an operation that accepts a single boolean-valued argument and returns no result. This
  * is the primitive type specialization of {@link java.util.function.Consumer} for boolean. Unlike
- * most other functional interfaces, BooleanConsumer is expected to operate via side-effects.
+ * most other functional interfaces, BooleanConsumer is expected to operate via side effects.
  *
  * <p>This is a functional interface whose functional method is {@link #accept(boolean)}.
  */
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/function/FloatConsumer.java b/wpiutil/src/main/java/edu/wpi/first/util/function/FloatConsumer.java
index 0fc7ff7..77970d8 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/function/FloatConsumer.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/function/FloatConsumer.java
@@ -7,7 +7,7 @@
 /**
  * Represents an operation that accepts a single float-valued argument and returns no result. This
  * is the primitive type specialization of {@link java.util.function.Consumer} for float. Unlike
- * most other functional interfaces, BooleanConsumer is expected to operate via side-effects.
+ * most other functional interfaces, BooleanConsumer is expected to operate via side effects.
  *
  * <p>This is a functional interface whose functional method is {@link #accept(float)}.
  */
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/net/PortForwarder.java b/wpiutil/src/main/java/edu/wpi/first/util/net/PortForwarder.java
deleted file mode 100644
index 5c4c20a..0000000
--- a/wpiutil/src/main/java/edu/wpi/first/util/net/PortForwarder.java
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.util.net;
-
-import edu.wpi.first.util.WPIUtilJNI;
-
-/**
- * Forward ports to another host. This is primarily useful for accessing Ethernet-connected devices
- * from a computer tethered to the RoboRIO USB port.
- */
-public final class PortForwarder {
-  private PortForwarder() {
-    throw new UnsupportedOperationException("This is a utility class!");
-  }
-
-  /**
-   * Forward a local TCP port to a remote host and port. Note that local ports less than 1024 won't
-   * work as a normal user.
-   *
-   * @param port local port number
-   * @param remoteHost remote IP address / DNS name
-   * @param remotePort remote port number
-   */
-  public static void add(int port, String remoteHost, int remotePort) {
-    WPIUtilJNI.addPortForwarder(port, remoteHost, remotePort);
-  }
-
-  /**
-   * Stop TCP forwarding on a port.
-   *
-   * @param port local port number
-   */
-  public static void remove(int port) {
-    WPIUtilJNI.removePortForwarder(port);
-  }
-}
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableBuilder.java b/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableBuilder.java
index 35d98fa..a58c3a3 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableBuilder.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableBuilder.java
@@ -5,13 +5,17 @@
 package edu.wpi.first.util.sendable;
 
 import edu.wpi.first.util.function.BooleanConsumer;
+import edu.wpi.first.util.function.FloatConsumer;
+import edu.wpi.first.util.function.FloatSupplier;
 import java.util.function.BooleanSupplier;
 import java.util.function.Consumer;
 import java.util.function.DoubleConsumer;
 import java.util.function.DoubleSupplier;
+import java.util.function.LongConsumer;
+import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 
-public interface SendableBuilder {
+public interface SendableBuilder extends AutoCloseable {
   /** The backend kinds used for the sendable builder. */
   enum BackendKind {
     kUnknown,
@@ -27,7 +31,7 @@
   void setSmartDashboardType(String type);
 
   /**
-   * Set a flag indicating if this sendable should be treated as an actuator. By default this flag
+   * Set a flag indicating if this Sendable should be treated as an actuator. By default, this flag
    * is false.
    *
    * @param value true if actuator, false if not
@@ -52,6 +56,24 @@
   void addBooleanProperty(String key, BooleanSupplier getter, BooleanConsumer setter);
 
   /**
+   * Add an integer property.
+   *
+   * @param key property name
+   * @param getter getter function (returns current value)
+   * @param setter setter function (sets new value)
+   */
+  void addIntegerProperty(String key, LongSupplier getter, LongConsumer setter);
+
+  /**
+   * Add a float property.
+   *
+   * @param key property name
+   * @param getter getter function (returns current value)
+   * @param setter setter function (sets new value)
+   */
+  void addFloatProperty(String key, FloatSupplier getter, FloatConsumer setter);
+
+  /**
    * Add a double property.
    *
    * @param key property name
@@ -79,6 +101,24 @@
   void addBooleanArrayProperty(String key, Supplier<boolean[]> getter, Consumer<boolean[]> setter);
 
   /**
+   * Add an integer array property.
+   *
+   * @param key property name
+   * @param getter getter function (returns current value)
+   * @param setter setter function (sets new value)
+   */
+  void addIntegerArrayProperty(String key, Supplier<long[]> getter, Consumer<long[]> setter);
+
+  /**
+   * Add a float array property.
+   *
+   * @param key property name
+   * @param getter getter function (returns current value)
+   * @param setter setter function (sets new value)
+   */
+  void addFloatArrayProperty(String key, Supplier<float[]> getter, Consumer<float[]> setter);
+
+  /**
    * Add a double array property.
    *
    * @param key property name
@@ -100,10 +140,12 @@
    * Add a raw property.
    *
    * @param key property name
+   * @param typeString type string
    * @param getter getter function (returns current value)
    * @param setter setter function (sets new value)
    */
-  void addRawProperty(String key, Supplier<byte[]> getter, Consumer<byte[]> setter);
+  void addRawProperty(
+      String key, String typeString, Supplier<byte[]> getter, Consumer<byte[]> setter);
 
   /**
    * Gets the kind of backend being used.
@@ -124,4 +166,11 @@
 
   /** Clear properties. */
   void clearProperties();
+
+  /**
+   * Adds a closeable. The closeable.close() will be called when close() is called.
+   *
+   * @param closeable closeable object
+   */
+  void addCloseable(AutoCloseable closeable);
 }
diff --git a/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableRegistry.java b/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableRegistry.java
index 2a4c2c9..6f0ad41 100644
--- a/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableRegistry.java
+++ b/wpiutil/src/main/java/edu/wpi/first/util/sendable/SendableRegistry.java
@@ -17,21 +17,32 @@
  * The SendableRegistry class is the public interface for registering sensors and actuators for use
  * on dashboards and LiveWindow.
  */
-public class SendableRegistry {
-  private static class Component {
+@SuppressWarnings("PMD.AvoidCatchingGenericException")
+public final class SendableRegistry {
+  private static class Component implements AutoCloseable {
     Component() {}
 
     Component(Sendable sendable) {
       m_sendable = new WeakReference<>(sendable);
     }
 
+    @Override
+    public void close() throws Exception {
+      m_builder.close();
+      for (AutoCloseable data : m_data) {
+        if (data != null) {
+          data.close();
+        }
+      }
+    }
+
     WeakReference<Sendable> m_sendable;
     SendableBuilder m_builder;
     String m_name;
     String m_subsystem = "Ungrouped";
     WeakReference<Sendable> m_parent;
     boolean m_liveWindow;
-    Object[] m_data;
+    AutoCloseable[] m_data;
 
     void setName(String moduleType, int channel) {
       m_name = moduleType + "[" + channel + "]";
@@ -131,6 +142,13 @@
   public static synchronized void addLW(Sendable sendable, String name) {
     Component comp = getOrAdd(sendable);
     if (liveWindowFactory != null) {
+      if (comp.m_builder != null) {
+        try {
+          comp.m_builder.close();
+        } catch (Exception e) {
+          // ignore
+        }
+      }
       comp.m_builder = liveWindowFactory.get();
     }
     comp.m_liveWindow = true;
@@ -147,6 +165,13 @@
   public static synchronized void addLW(Sendable sendable, String moduleType, int channel) {
     Component comp = getOrAdd(sendable);
     if (liveWindowFactory != null) {
+      if (comp.m_builder != null) {
+        try {
+          comp.m_builder.close();
+        } catch (Exception e) {
+          // ignore
+        }
+      }
       comp.m_builder = liveWindowFactory.get();
     }
     comp.m_liveWindow = true;
@@ -165,6 +190,13 @@
       Sendable sendable, String moduleType, int moduleNumber, int channel) {
     Component comp = getOrAdd(sendable);
     if (liveWindowFactory != null) {
+      if (comp.m_builder != null) {
+        try {
+          comp.m_builder.close();
+        } catch (Exception e) {
+          // ignore
+        }
+      }
       comp.m_builder = liveWindowFactory.get();
     }
     comp.m_liveWindow = true;
@@ -181,6 +213,13 @@
   public static synchronized void addLW(Sendable sendable, String subsystem, String name) {
     Component comp = getOrAdd(sendable);
     if (liveWindowFactory != null) {
+      if (comp.m_builder != null) {
+        try {
+          comp.m_builder.close();
+        } catch (Exception e) {
+          // ignore
+        }
+      }
       comp.m_builder = liveWindowFactory.get();
     }
     comp.m_liveWindow = true;
@@ -211,7 +250,15 @@
    * @return true if the object was removed; false if it was not present
    */
   public static synchronized boolean remove(Sendable sendable) {
-    return components.remove(sendable) != null;
+    Component comp = components.remove(sendable);
+    if (comp != null) {
+      try {
+        comp.close();
+      } catch (Exception e) {
+        // ignore
+      }
+    }
+    return comp != null;
   }
 
   /**
@@ -338,22 +385,33 @@
    * @param sendable object
    * @param handle data handle returned by getDataHandle()
    * @param data data to set
-   * @return Previous data (may be null)
+   * @return Previous data (may be null). If non-null, caller is responsible for calling close().
    */
-  public static synchronized Object setData(Sendable sendable, int handle, Object data) {
+  @SuppressWarnings("PMD.CompareObjectsWithEquals")
+  public static synchronized AutoCloseable setData(
+      Sendable sendable, int handle, AutoCloseable data) {
     Component comp = components.get(sendable);
     if (comp == null) {
       return null;
     }
-    Object rv = null;
+    AutoCloseable rv = null;
     if (comp.m_data == null) {
-      comp.m_data = new Object[handle + 1];
+      comp.m_data = new AutoCloseable[handle + 1];
     } else if (handle < comp.m_data.length) {
       rv = comp.m_data[handle];
     } else {
       comp.m_data = Arrays.copyOf(comp.m_data, handle + 1);
     }
-    comp.m_data[handle] = data;
+    if (comp.m_data[handle] != data) {
+      if (comp.m_data[handle] != null) {
+        try {
+          comp.m_data[handle].close();
+        } catch (Exception e) {
+          // ignore
+        }
+      }
+      comp.m_data[handle] = data;
+    }
     return rv;
   }
 
@@ -405,7 +463,11 @@
   public static synchronized void publish(Sendable sendable, SendableBuilder builder) {
     Component comp = getOrAdd(sendable);
     if (comp.m_builder != null) {
-      comp.m_builder.clearProperties();
+      try {
+        comp.m_builder.close();
+      } catch (Exception e) {
+        // ignore
+      }
     }
     comp.m_builder = builder; // clear any current builder
     sendable.initSendable(comp.m_builder);
@@ -425,29 +487,24 @@
   }
 
   /** Data passed to foreachLiveWindow() callback function. */
+  @SuppressWarnings("MemberName")
   public static class CallbackData {
     /** Sendable object. */
-    @SuppressWarnings("MemberName")
     public Sendable sendable;
 
     /** Name. */
-    @SuppressWarnings("MemberName")
     public String name;
 
     /** Subsystem. */
-    @SuppressWarnings("MemberName")
     public String subsystem;
 
     /** Parent sendable object. */
-    @SuppressWarnings("MemberName")
     public Sendable parent;
 
     /** Data stored in object with setData(). Update this to change the data. */
-    @SuppressWarnings("MemberName")
-    public Object data;
+    public AutoCloseable data;
 
     /** Sendable builder for the sendable. */
-    @SuppressWarnings("MemberName")
     public SendableBuilder builder;
   }
 
@@ -462,7 +519,7 @@
    * @param dataHandle data handle to get data object passed to callback
    * @param callback function to call for each object
    */
-  @SuppressWarnings({"PMD.AvoidCatchingThrowable", "PMD.AvoidReassigningCatchVariables"})
+  @SuppressWarnings("PMD.CompareObjectsWithEquals")
   public static synchronized void foreachLiveWindow(
       int dataHandle, Consumer<CallbackData> callback) {
     CallbackData cbdata = new CallbackData();
@@ -500,11 +557,20 @@
         }
         if (cbdata.data != null) {
           if (comp.m_data == null) {
-            comp.m_data = new Object[dataHandle + 1];
+            comp.m_data = new AutoCloseable[dataHandle + 1];
           } else if (dataHandle >= comp.m_data.length) {
             comp.m_data = Arrays.copyOf(comp.m_data, dataHandle + 1);
           }
-          comp.m_data[dataHandle] = cbdata.data;
+          if (comp.m_data[dataHandle] != cbdata.data) {
+            if (comp.m_data[dataHandle] != null) {
+              try {
+                comp.m_data[dataHandle].close();
+              } catch (Exception e) {
+                // ignore
+              }
+            }
+            comp.m_data[dataHandle] = cbdata.data;
+          }
         }
       }
     }
diff --git a/wpiutil/src/main/native/cpp/Base64.cpp b/wpiutil/src/main/native/cpp/Base64.cpp
index 8f1f810..bc1d3ba 100644
--- a/wpiutil/src/main/native/cpp/Base64.cpp
+++ b/wpiutil/src/main/native/cpp/Base64.cpp
@@ -138,8 +138,8 @@
   return Base64Decode(os, encoded);
 }
 
-span<uint8_t> Base64Decode(std::string_view encoded, size_t* num_read,
-                           SmallVectorImpl<uint8_t>& buf) {
+std::span<uint8_t> Base64Decode(std::string_view encoded, size_t* num_read,
+                                SmallVectorImpl<uint8_t>& buf) {
   buf.clear();
   raw_usvector_ostream os(buf);
   *num_read = Base64Decode(os, encoded);
@@ -193,19 +193,19 @@
   return os.str();
 }
 
-void Base64Encode(raw_ostream& os, span<const uint8_t> plain) {
+void Base64Encode(raw_ostream& os, std::span<const uint8_t> plain) {
   Base64Encode(os, std::string_view{reinterpret_cast<const char*>(plain.data()),
                                     plain.size()});
 }
 
-void Base64Encode(span<const uint8_t> plain, std::string* encoded) {
+void Base64Encode(std::span<const uint8_t> plain, std::string* encoded) {
   encoded->resize(0);
   raw_string_ostream os(*encoded);
   Base64Encode(os, plain);
   os.flush();
 }
 
-std::string_view Base64Encode(span<const uint8_t> plain,
+std::string_view Base64Encode(std::span<const uint8_t> plain,
                               SmallVectorImpl<char>& buf) {
   buf.clear();
   raw_svector_ostream os(buf);
diff --git a/wpiutil/src/main/native/cpp/DataLog.cpp b/wpiutil/src/main/native/cpp/DataLog.cpp
new file mode 100644
index 0000000..7009628
--- /dev/null
+++ b/wpiutil/src/main/native/cpp/DataLog.cpp
@@ -0,0 +1,821 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/DataLog.h"
+
+#include "wpi/Synchronization.h"
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>  // NOLINT(build/include_order)
+
+#endif
+
+#include <atomic>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <random>
+#include <vector>
+
+#include "fmt/format.h"
+#include "wpi/Endian.h"
+#include "wpi/Logger.h"
+#include "wpi/MathExtras.h"
+#include "wpi/fs.h"
+#include "wpi/timestamp.h"
+
+using namespace wpi::log;
+
+static constexpr size_t kBlockSize = 16 * 1024;
+static constexpr size_t kRecordMaxHeaderSize = 17;
+
+template <typename T>
+static unsigned int WriteVarInt(uint8_t* buf, T val) {
+  unsigned int len = 0;
+  do {
+    *buf++ = static_cast<unsigned int>(val) & 0xff;
+    ++len;
+    val >>= 8;
+  } while (val != 0);
+  return len;
+}
+
+// min size: 4, max size: 17
+static unsigned int WriteRecordHeader(uint8_t* buf, uint32_t entry,
+                                      uint64_t timestamp,
+                                      uint32_t payloadSize) {
+  uint8_t* origbuf = buf++;
+
+  unsigned int entryLen = WriteVarInt(buf, entry);
+  buf += entryLen;
+  unsigned int payloadLen = WriteVarInt(buf, payloadSize);
+  buf += payloadLen;
+  unsigned int timestampLen =
+      WriteVarInt(buf, timestamp == 0 ? wpi::Now() : timestamp);
+  buf += timestampLen;
+  *origbuf =
+      ((timestampLen - 1) << 4) | ((payloadLen - 1) << 2) | (entryLen - 1);
+  return buf - origbuf;
+}
+
+class DataLog::Buffer {
+ public:
+  explicit Buffer(size_t alloc = kBlockSize)
+      : m_buf{new uint8_t[alloc]}, m_maxLen{alloc} {}
+  ~Buffer() { delete[] m_buf; }
+
+  Buffer(const Buffer&) = delete;
+  Buffer& operator=(const Buffer&) = delete;
+
+  Buffer(Buffer&& oth)
+      : m_buf{oth.m_buf}, m_len{oth.m_len}, m_maxLen{oth.m_maxLen} {
+    oth.m_buf = nullptr;
+    oth.m_len = 0;
+    oth.m_maxLen = 0;
+  }
+
+  Buffer& operator=(Buffer&& oth) {
+    if (m_buf) {
+      delete[] m_buf;
+    }
+    m_buf = oth.m_buf;
+    m_len = oth.m_len;
+    m_maxLen = oth.m_maxLen;
+    oth.m_buf = nullptr;
+    oth.m_len = 0;
+    oth.m_maxLen = 0;
+    return *this;
+  }
+
+  uint8_t* Reserve(size_t size) {
+    assert(size <= GetRemaining());
+    uint8_t* rv = m_buf + m_len;
+    m_len += size;
+    return rv;
+  }
+
+  void Unreserve(size_t size) { m_len -= size; }
+
+  void Clear() { m_len = 0; }
+
+  size_t GetRemaining() const { return m_maxLen - m_len; }
+
+  std::span<uint8_t> GetData() { return {m_buf, m_len}; }
+  std::span<const uint8_t> GetData() const { return {m_buf, m_len}; }
+
+ private:
+  uint8_t* m_buf;
+  size_t m_len = 0;
+  size_t m_maxLen;
+};
+
+static void DefaultLog(unsigned int level, const char* file, unsigned int line,
+                       const char* msg) {
+  if (level > wpi::WPI_LOG_INFO) {
+    fmt::print(stderr, "DataLog: {}\n", msg);
+  } else if (level == wpi::WPI_LOG_INFO) {
+    fmt::print("DataLog: {}\n", msg);
+  }
+}
+
+static wpi::Logger defaultMessageLog{DefaultLog};
+
+DataLog::DataLog(std::string_view dir, std::string_view filename, double period,
+                 std::string_view extraHeader)
+    : DataLog{defaultMessageLog, dir, filename, period, extraHeader} {}
+
+DataLog::DataLog(wpi::Logger& msglog, std::string_view dir,
+                 std::string_view filename, double period,
+                 std::string_view extraHeader)
+    : m_msglog{msglog},
+      m_period{period},
+      m_extraHeader{extraHeader},
+      m_newFilename{filename},
+      m_thread{[this, dir = std::string{dir}] { WriterThreadMain(dir); }} {}
+
+DataLog::DataLog(std::function<void(std::span<const uint8_t> data)> write,
+                 double period, std::string_view extraHeader)
+    : DataLog{defaultMessageLog, std::move(write), period, extraHeader} {}
+
+DataLog::DataLog(wpi::Logger& msglog,
+                 std::function<void(std::span<const uint8_t> data)> write,
+                 double period, std::string_view extraHeader)
+    : m_msglog{msglog},
+      m_period{period},
+      m_extraHeader{extraHeader},
+      m_thread{[this, write = std::move(write)] {
+        WriterThreadMain(std::move(write));
+      }} {}
+
+DataLog::~DataLog() {
+  {
+    std::scoped_lock lock{m_mutex};
+    m_active = false;
+    m_doFlush = true;
+  }
+  m_cond.notify_all();
+  m_thread.join();
+}
+
+void DataLog::SetFilename(std::string_view filename) {
+  {
+    std::scoped_lock lock{m_mutex};
+    m_newFilename = filename;
+  }
+  m_cond.notify_all();
+}
+
+void DataLog::Flush() {
+  {
+    std::scoped_lock lock{m_mutex};
+    m_doFlush = true;
+  }
+  m_cond.notify_all();
+}
+
+void DataLog::Pause() {
+  std::scoped_lock lock{m_mutex};
+  m_paused = true;
+}
+
+void DataLog::Resume() {
+  std::scoped_lock lock{m_mutex};
+  m_paused = false;
+}
+
+static void WriteToFile(fs::file_t f, std::span<const uint8_t> data,
+                        std::string_view filename, wpi::Logger& msglog) {
+  do {
+#ifdef _WIN32
+    DWORD ret;
+    if (!WriteFile(f, data.data(), data.size(), &ret, nullptr)) {
+      WPI_ERROR(msglog, "Error writing to log file '{}': {}", filename,
+                GetLastError());
+      break;
+    }
+#else
+    ssize_t ret = ::write(f, data.data(), data.size());
+    if (ret < 0) {
+      // If it's a recoverable error, swallow it and retry the write
+      if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) {
+        continue;
+      }
+
+      // Otherwise it's a non-recoverable error; quit trying
+      WPI_ERROR(msglog, "Error writing to log file '{}': {}", filename,
+                std::strerror(errno));
+      break;
+    }
+#endif
+
+    // The write may have written some or all of the data
+    data = data.subspan(ret);
+  } while (data.size() > 0);
+}
+
+static std::string MakeRandomFilename() {
+  // build random filename
+  static std::random_device dev;
+  static std::mt19937 rng(dev());
+  std::uniform_int_distribution<int> dist(0, 15);
+  const char* v = "0123456789abcdef";
+  std::string filename = "wpilog_";
+  for (int i = 0; i < 16; i++) {
+    filename += v[dist(rng)];
+  }
+  filename += ".wpilog";
+  return filename;
+}
+
+void DataLog::WriterThreadMain(std::string_view dir) {
+  std::chrono::duration<double> periodTime{m_period};
+
+  std::error_code ec;
+  fs::path dirPath{dir};
+  std::string filename;
+
+  {
+    std::scoped_lock lock{m_mutex};
+    filename = std::move(m_newFilename);
+    m_newFilename.clear();
+  }
+
+  if (filename.empty()) {
+    filename = MakeRandomFilename();
+  }
+
+  // try preferred filename, or randomize it a few times, before giving up
+  fs::file_t f;
+  for (int i = 0; i < 5; ++i) {
+    // open file for append
+#ifdef _WIN32
+    // WIN32 doesn't allow combination of CreateNew and Append
+    f = fs::OpenFileForWrite(dirPath / filename, ec, fs::CD_CreateNew,
+                             fs::OF_None);
+#else
+    f = fs::OpenFileForWrite(dirPath / filename, ec, fs::CD_CreateNew,
+                             fs::OF_Append);
+#endif
+    if (ec) {
+      WPI_ERROR(m_msglog, "Could not open log file '{}': {}",
+                (dirPath / filename).string(), ec.message());
+      // try again with random filename
+      filename = MakeRandomFilename();
+    } else {
+      break;
+    }
+  }
+
+  if (f == fs::kInvalidFile) {
+    WPI_ERROR(m_msglog, "Could not open log file, no log being saved");
+  } else {
+    WPI_INFO(m_msglog, "Logging to '{}'", (dirPath / filename).string());
+  }
+
+  // write header (version 1.0)
+  if (f != fs::kInvalidFile) {
+    const uint8_t header[] = {'W', 'P', 'I', 'L', 'O', 'G', 0, 1};
+    WriteToFile(f, header, filename, m_msglog);
+    uint8_t extraLen[4];
+    support::endian::write32le(extraLen, m_extraHeader.size());
+    WriteToFile(f, extraLen, filename, m_msglog);
+    if (m_extraHeader.size() > 0) {
+      WriteToFile(f,
+                  {reinterpret_cast<const uint8_t*>(m_extraHeader.data()),
+                   m_extraHeader.size()},
+                  filename, m_msglog);
+    }
+  }
+
+  std::vector<Buffer> toWrite;
+
+  std::unique_lock lock{m_mutex};
+  while (m_active) {
+    bool doFlush = false;
+    auto timeoutTime = std::chrono::steady_clock::now() + periodTime;
+    if (m_cond.wait_until(lock, timeoutTime) == std::cv_status::timeout) {
+      doFlush = true;
+    }
+
+    if (!m_newFilename.empty()) {
+      auto newFilename = std::move(m_newFilename);
+      m_newFilename.clear();
+      lock.unlock();
+      // rename
+      if (filename != newFilename) {
+        fs::rename(dirPath / filename, dirPath / newFilename, ec);
+      }
+      if (ec) {
+        WPI_ERROR(m_msglog, "Could not rename log file from '{}' to '{}': {}",
+                  filename, newFilename, ec.message());
+      } else {
+        WPI_INFO(m_msglog, "Renamed log file from '{}' to '{}'", filename,
+                 newFilename);
+      }
+      filename = std::move(newFilename);
+      lock.lock();
+    }
+
+    if (doFlush || m_doFlush) {
+      // flush to file
+      m_doFlush = false;
+      if (m_outgoing.empty()) {
+        continue;
+      }
+      // swap outgoing with empty vector
+      toWrite.swap(m_outgoing);
+
+      if (f != fs::kInvalidFile) {
+        lock.unlock();
+        // write buffers to file
+        for (auto&& buf : toWrite) {
+          WriteToFile(f, buf.GetData(), filename, m_msglog);
+        }
+
+        // sync to storage
+#if defined(__linux__)
+        ::fdatasync(f);
+#elif defined(__APPLE__)
+        ::fsync(f);
+#endif
+        lock.lock();
+      }
+
+      // release buffers back to free list
+      for (auto&& buf : toWrite) {
+        buf.Clear();
+        m_free.emplace_back(std::move(buf));
+      }
+      toWrite.resize(0);
+    }
+  }
+
+  if (f != fs::kInvalidFile) {
+    fs::CloseFile(f);
+  }
+}
+
+void DataLog::WriterThreadMain(
+    std::function<void(std::span<const uint8_t> data)> write) {
+  std::chrono::duration<double> periodTime{m_period};
+
+  // write header (version 1.0)
+  {
+    const uint8_t header[] = {'W', 'P', 'I', 'L', 'O', 'G', 0, 1};
+    write(header);
+    uint8_t extraLen[4];
+    support::endian::write32le(extraLen, m_extraHeader.size());
+    write(extraLen);
+    if (m_extraHeader.size() > 0) {
+      write({reinterpret_cast<const uint8_t*>(m_extraHeader.data()),
+             m_extraHeader.size()});
+    }
+  }
+
+  std::vector<Buffer> toWrite;
+
+  std::unique_lock lock{m_mutex};
+  while (m_active) {
+    bool doFlush = false;
+    auto timeoutTime = std::chrono::steady_clock::now() + periodTime;
+    if (m_cond.wait_until(lock, timeoutTime) == std::cv_status::timeout) {
+      doFlush = true;
+    }
+
+    if (doFlush || m_doFlush) {
+      // flush to file
+      m_doFlush = false;
+      if (m_outgoing.empty()) {
+        continue;
+      }
+      // swap outgoing with empty vector
+      toWrite.swap(m_outgoing);
+
+      lock.unlock();
+      // write buffers
+      for (auto&& buf : toWrite) {
+        if (!buf.GetData().empty()) {
+          write(buf.GetData());
+        }
+      }
+      lock.lock();
+
+      // release buffers back to free list
+      for (auto&& buf : toWrite) {
+        buf.Clear();
+        m_free.emplace_back(std::move(buf));
+      }
+      toWrite.resize(0);
+    }
+  }
+
+  write({});  // indicate EOF
+}
+
+// Control records use the following format:
+// 1-byte type
+// 4-byte entry
+// rest of data (depending on type)
+
+int DataLog::Start(std::string_view name, std::string_view type,
+                   std::string_view metadata, int64_t timestamp) {
+  std::scoped_lock lock{m_mutex};
+  auto& entryInfo = m_entries[name];
+  if (entryInfo.id == 0) {
+    entryInfo.id = ++m_lastId;
+  }
+  auto& savedCount = m_entryCounts[entryInfo.id];
+  ++savedCount;
+  if (savedCount > 1) {
+    if (entryInfo.type != type) {
+      WPI_ERROR(m_msglog,
+                "type mismatch for '{}': was '{}', requested '{}'; ignoring",
+                name, entryInfo.type, type);
+      return 0;
+    }
+    return entryInfo.id;
+  }
+  entryInfo.type = type;
+  size_t strsize = name.size() + type.size() + metadata.size();
+  uint8_t* buf = StartRecord(0, timestamp, 5 + 12 + strsize, 5);
+  *buf++ = impl::kControlStart;
+  wpi::support::endian::write32le(buf, entryInfo.id);
+  AppendStringImpl(name);
+  AppendStringImpl(type);
+  AppendStringImpl(metadata);
+
+  return entryInfo.id;
+}
+
+void DataLog::Finish(int entry, int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  auto& savedCount = m_entryCounts[entry];
+  if (savedCount == 0) {
+    return;
+  }
+  --savedCount;
+  if (savedCount != 0) {
+    return;
+  }
+  m_entryCounts.erase(entry);
+  uint8_t* buf = StartRecord(0, timestamp, 5, 5);
+  *buf++ = impl::kControlFinish;
+  wpi::support::endian::write32le(buf, entry);
+}
+
+void DataLog::SetMetadata(int entry, std::string_view metadata,
+                          int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  uint8_t* buf = StartRecord(0, timestamp, 5 + 4 + metadata.size(), 5);
+  *buf++ = impl::kControlSetMetadata;
+  wpi::support::endian::write32le(buf, entry);
+  AppendStringImpl(metadata);
+}
+
+uint8_t* DataLog::Reserve(size_t size) {
+  assert(size <= kBlockSize);
+  if (m_outgoing.empty() || size > m_outgoing.back().GetRemaining()) {
+    if (m_free.empty()) {
+      m_outgoing.emplace_back();
+    } else {
+      m_outgoing.emplace_back(std::move(m_free.back()));
+      m_free.pop_back();
+    }
+  }
+  return m_outgoing.back().Reserve(size);
+}
+
+uint8_t* DataLog::StartRecord(uint32_t entry, uint64_t timestamp,
+                              uint32_t payloadSize, size_t reserveSize) {
+  uint8_t* buf = Reserve(kRecordMaxHeaderSize + reserveSize);
+  auto headerLen = WriteRecordHeader(buf, entry, timestamp, payloadSize);
+  m_outgoing.back().Unreserve(kRecordMaxHeaderSize - headerLen);
+  buf += headerLen;
+  return buf;
+}
+
+void DataLog::AppendImpl(std::span<const uint8_t> data) {
+  while (data.size() > kBlockSize) {
+    uint8_t* buf = Reserve(kBlockSize);
+    std::memcpy(buf, data.data(), kBlockSize);
+    data = data.subspan(kBlockSize);
+  }
+  uint8_t* buf = Reserve(data.size());
+  std::memcpy(buf, data.data(), data.size());
+}
+
+void DataLog::AppendStringImpl(std::string_view str) {
+  uint8_t* buf = Reserve(4);
+  wpi::support::endian::write32le(buf, str.size());
+  AppendImpl({reinterpret_cast<const uint8_t*>(str.data()), str.size()});
+}
+
+void DataLog::AppendRaw(int entry, std::span<const uint8_t> data,
+                        int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  StartRecord(entry, timestamp, data.size(), 0);
+  AppendImpl(data);
+}
+
+void DataLog::AppendRaw2(int entry,
+                         std::span<const std::span<const uint8_t>> data,
+                         int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  size_t size = 0;
+  for (auto&& chunk : data) {
+    size += chunk.size();
+  }
+  StartRecord(entry, timestamp, size, 0);
+  for (auto chunk : data) {
+    AppendImpl(chunk);
+  }
+}
+
+void DataLog::AppendBoolean(int entry, bool value, int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, 1, 1);
+  buf[0] = value ? 1 : 0;
+}
+
+void DataLog::AppendInteger(int entry, int64_t value, int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, 8, 8);
+  wpi::support::endian::write64le(buf, value);
+}
+
+void DataLog::AppendFloat(int entry, float value, int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, 4, 4);
+  if constexpr (wpi::support::endian::system_endianness() ==
+                wpi::support::little) {
+    std::memcpy(buf, &value, 4);
+  } else {
+    wpi::support::endian::write32le(buf, wpi::FloatToBits(value));
+  }
+}
+
+void DataLog::AppendDouble(int entry, double value, int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, 8, 8);
+  if constexpr (wpi::support::endian::system_endianness() ==
+                wpi::support::little) {
+    std::memcpy(buf, &value, 8);
+  } else {
+    wpi::support::endian::write64le(buf, wpi::DoubleToBits(value));
+  }
+}
+
+void DataLog::AppendString(int entry, std::string_view value,
+                           int64_t timestamp) {
+  AppendRaw(entry,
+            {reinterpret_cast<const uint8_t*>(value.data()), value.size()},
+            timestamp);
+}
+
+void DataLog::AppendBooleanArray(int entry, std::span<const bool> arr,
+                                 int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  StartRecord(entry, timestamp, arr.size(), 0);
+  uint8_t* buf;
+  while (arr.size() > kBlockSize) {
+    buf = Reserve(kBlockSize);
+    for (auto val : arr.subspan(0, kBlockSize)) {
+      *buf++ = val ? 1 : 0;
+    }
+    arr = arr.subspan(kBlockSize);
+  }
+  buf = Reserve(arr.size());
+  for (auto val : arr) {
+    *buf++ = val ? 1 : 0;
+  }
+}
+
+void DataLog::AppendBooleanArray(int entry, std::span<const int> arr,
+                                 int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  StartRecord(entry, timestamp, arr.size(), 0);
+  uint8_t* buf;
+  while (arr.size() > kBlockSize) {
+    buf = Reserve(kBlockSize);
+    for (auto val : arr.subspan(0, kBlockSize)) {
+      *buf++ = val & 1;
+    }
+    arr = arr.subspan(kBlockSize);
+  }
+  buf = Reserve(arr.size());
+  for (auto val : arr) {
+    *buf++ = val & 1;
+  }
+}
+
+void DataLog::AppendBooleanArray(int entry, std::span<const uint8_t> arr,
+                                 int64_t timestamp) {
+  AppendRaw(entry, arr, timestamp);
+}
+
+void DataLog::AppendIntegerArray(int entry, std::span<const int64_t> arr,
+                                 int64_t timestamp) {
+  if constexpr (wpi::support::endian::system_endianness() ==
+                wpi::support::little) {
+    AppendRaw(entry,
+              {reinterpret_cast<const uint8_t*>(arr.data()), arr.size() * 8},
+              timestamp);
+  } else {
+    if (entry <= 0) {
+      return;
+    }
+    std::scoped_lock lock{m_mutex};
+    if (m_paused) {
+      return;
+    }
+    StartRecord(entry, timestamp, arr.size() * 8, 0);
+    uint8_t* buf;
+    while ((arr.size() * 8) > kBlockSize) {
+      buf = Reserve(kBlockSize);
+      for (auto val : arr.subspan(0, kBlockSize / 8)) {
+        wpi::support::endian::write64le(buf, val);
+        buf += 8;
+      }
+      arr = arr.subspan(kBlockSize / 8);
+    }
+    buf = Reserve(arr.size() * 8);
+    for (auto val : arr) {
+      wpi::support::endian::write64le(buf, val);
+      buf += 8;
+    }
+  }
+}
+
+void DataLog::AppendFloatArray(int entry, std::span<const float> arr,
+                               int64_t timestamp) {
+  if constexpr (wpi::support::endian::system_endianness() ==
+                wpi::support::little) {
+    AppendRaw(entry,
+              {reinterpret_cast<const uint8_t*>(arr.data()), arr.size() * 4},
+              timestamp);
+  } else {
+    if (entry <= 0) {
+      return;
+    }
+    std::scoped_lock lock{m_mutex};
+    if (m_paused) {
+      return;
+    }
+    StartRecord(entry, timestamp, arr.size() * 4, 0);
+    uint8_t* buf;
+    while ((arr.size() * 4) > kBlockSize) {
+      buf = Reserve(kBlockSize);
+      for (auto val : arr.subspan(0, kBlockSize / 4)) {
+        wpi::support::endian::write32le(buf, wpi::FloatToBits(val));
+        buf += 4;
+      }
+      arr = arr.subspan(kBlockSize / 4);
+    }
+    buf = Reserve(arr.size() * 4);
+    for (auto val : arr) {
+      wpi::support::endian::write32le(buf, wpi::FloatToBits(val));
+      buf += 4;
+    }
+  }
+}
+
+void DataLog::AppendDoubleArray(int entry, std::span<const double> arr,
+                                int64_t timestamp) {
+  if constexpr (wpi::support::endian::system_endianness() ==
+                wpi::support::little) {
+    AppendRaw(entry,
+              {reinterpret_cast<const uint8_t*>(arr.data()), arr.size() * 8},
+              timestamp);
+  } else {
+    if (entry <= 0) {
+      return;
+    }
+    std::scoped_lock lock{m_mutex};
+    if (m_paused) {
+      return;
+    }
+    StartRecord(entry, timestamp, arr.size() * 8, 0);
+    uint8_t* buf;
+    while ((arr.size() * 8) > kBlockSize) {
+      buf = Reserve(kBlockSize);
+      for (auto val : arr.subspan(0, kBlockSize / 8)) {
+        wpi::support::endian::write64le(buf, wpi::DoubleToBits(val));
+        buf += 8;
+      }
+      arr = arr.subspan(kBlockSize / 8);
+    }
+    buf = Reserve(arr.size() * 8);
+    for (auto val : arr) {
+      wpi::support::endian::write64le(buf, wpi::DoubleToBits(val));
+      buf += 8;
+    }
+  }
+}
+
+void DataLog::AppendStringArray(int entry, std::span<const std::string> arr,
+                                int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  // storage: 4-byte array length, each string prefixed by 4-byte length
+  // calculate total size
+  size_t size = 4;
+  for (auto&& str : arr) {
+    size += 4 + str.size();
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, size, 4);
+  wpi::support::endian::write32le(buf, arr.size());
+  for (auto&& str : arr) {
+    AppendStringImpl(str);
+  }
+}
+
+void DataLog::AppendStringArray(int entry,
+                                std::span<const std::string_view> arr,
+                                int64_t timestamp) {
+  if (entry <= 0) {
+    return;
+  }
+  // storage: 4-byte array length, each string prefixed by 4-byte length
+  // calculate total size
+  size_t size = 4;
+  for (auto&& str : arr) {
+    size += 4 + str.size();
+  }
+  std::scoped_lock lock{m_mutex};
+  if (m_paused) {
+    return;
+  }
+  uint8_t* buf = StartRecord(entry, timestamp, size, 4);
+  wpi::support::endian::write32le(buf, arr.size());
+  for (auto sv : arr) {
+    AppendStringImpl(sv);
+  }
+}
diff --git a/wpiutil/src/main/native/cpp/DataLogReader.cpp b/wpiutil/src/main/native/cpp/DataLogReader.cpp
new file mode 100644
index 0000000..96f6689
--- /dev/null
+++ b/wpiutil/src/main/native/cpp/DataLogReader.cpp
@@ -0,0 +1,307 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/DataLogReader.h"
+
+#include "wpi/DataLog.h"
+#include "wpi/Endian.h"
+#include "wpi/MathExtras.h"
+
+using namespace wpi::log;
+
+static bool ReadString(std::span<const uint8_t>* buf, std::string_view* str) {
+  if (buf->size() < 4) {
+    *str = {};
+    return false;
+  }
+  uint32_t len = wpi::support::endian::read32le(buf->data());
+  if (len > (buf->size() - 4)) {
+    *str = {};
+    return false;
+  }
+  *str = {reinterpret_cast<const char*>(buf->data() + 4), len};
+  *buf = buf->subspan(len + 4);
+  return true;
+}
+
+bool DataLogRecord::IsStart() const {
+  return m_entry == 0 && m_data.size() >= 17 &&
+         m_data[0] == impl::kControlStart;
+}
+
+bool DataLogRecord::IsFinish() const {
+  return m_entry == 0 && m_data.size() == 5 &&
+         m_data[0] == impl::kControlFinish;
+}
+
+bool DataLogRecord::IsSetMetadata() const {
+  return m_entry == 0 && m_data.size() >= 9 &&
+         m_data[0] == impl::kControlSetMetadata;
+}
+
+bool DataLogRecord::GetStartData(StartRecordData* out) const {
+  if (!IsStart()) {
+    return false;
+  }
+  out->entry = wpi::support::endian::read32le(&m_data[1]);
+  auto buf = m_data.subspan(5);
+  if (!ReadString(&buf, &out->name)) {
+    return false;
+  }
+  if (!ReadString(&buf, &out->type)) {
+    return false;
+  }
+  if (!ReadString(&buf, &out->metadata)) {
+    return false;
+  }
+  return true;
+}
+
+bool DataLogRecord::GetFinishEntry(int* out) const {
+  if (!IsFinish()) {
+    return false;
+  }
+  *out = wpi::support::endian::read32le(&m_data[1]);
+  return true;
+}
+
+bool DataLogRecord::GetSetMetadataData(MetadataRecordData* out) const {
+  if (!IsSetMetadata()) {
+    return false;
+  }
+  out->entry = wpi::support::endian::read32le(&m_data[1]);
+  auto buf = m_data.subspan(5);
+  return ReadString(&buf, &out->metadata);
+}
+
+bool DataLogRecord::GetBoolean(bool* value) const {
+  if (m_data.size() != 1) {
+    return false;
+  }
+  *value = m_data[0] != 0;
+  return true;
+}
+
+bool DataLogRecord::GetInteger(int64_t* value) const {
+  if (m_data.size() != 8) {
+    return false;
+  }
+  *value = wpi::support::endian::read64le(m_data.data());
+  return true;
+}
+
+bool DataLogRecord::GetFloat(float* value) const {
+  if (m_data.size() != 4) {
+    return false;
+  }
+  *value = wpi::BitsToFloat(wpi::support::endian::read32le(m_data.data()));
+  return true;
+}
+
+bool DataLogRecord::GetDouble(double* value) const {
+  if (m_data.size() != 8) {
+    return false;
+  }
+  *value = wpi::BitsToDouble(wpi::support::endian::read64le(m_data.data()));
+  return true;
+}
+
+bool DataLogRecord::GetString(std::string_view* value) const {
+  *value = {reinterpret_cast<const char*>(m_data.data()), m_data.size()};
+  return true;
+}
+
+bool DataLogRecord::GetBooleanArray(std::vector<int>* arr) const {
+  arr->clear();
+  arr->reserve(m_data.size());
+  for (auto v : m_data) {
+    arr->push_back(v);
+  }
+  return true;
+}
+
+bool DataLogRecord::GetIntegerArray(std::vector<int64_t>* arr) const {
+  arr->clear();
+  if ((m_data.size() % 8) != 0) {
+    return false;
+  }
+  arr->reserve(m_data.size() / 8);
+  for (size_t pos = 0; pos < m_data.size(); pos += 8) {
+    arr->push_back(wpi::support::endian::read64le(&m_data[pos]));
+  }
+  return true;
+}
+
+bool DataLogRecord::GetFloatArray(std::vector<float>* arr) const {
+  arr->clear();
+  if ((m_data.size() % 4) != 0) {
+    return false;
+  }
+  arr->reserve(m_data.size() / 4);
+  for (size_t pos = 0; pos < m_data.size(); pos += 4) {
+    arr->push_back(
+        wpi::BitsToFloat(wpi::support::endian::read32le(&m_data[pos])));
+  }
+  return true;
+}
+
+bool DataLogRecord::GetDoubleArray(std::vector<double>* arr) const {
+  arr->clear();
+  if ((m_data.size() % 8) != 0) {
+    return false;
+  }
+  arr->reserve(m_data.size() / 8);
+  for (size_t pos = 0; pos < m_data.size(); pos += 8) {
+    arr->push_back(
+        wpi::BitsToDouble(wpi::support::endian::read64le(&m_data[pos])));
+  }
+  return true;
+}
+
+bool DataLogRecord::GetStringArray(std::vector<std::string_view>* arr) const {
+  arr->clear();
+  if (m_data.size() < 4) {
+    return false;
+  }
+  uint32_t size = wpi::support::endian::read32le(m_data.data());
+  // sanity check size
+  if (size > ((m_data.size() - 4) / 4)) {
+    return false;
+  }
+  auto buf = m_data.subspan(4);
+  arr->reserve(size);
+  for (uint32_t i = 0; i < size; ++i) {
+    std::string_view str;
+    if (!ReadString(&buf, &str)) {
+      arr->clear();
+      return false;
+    }
+    arr->push_back(str);
+  }
+  // any left over?  treat as corrupt
+  if (!buf.empty()) {
+    arr->clear();
+    return false;
+  }
+  return true;
+}
+
+DataLogReader::DataLogReader(std::unique_ptr<MemoryBuffer> buffer)
+    : m_buf{std::move(buffer)} {}
+
+bool DataLogReader::IsValid() const {
+  if (!m_buf) {
+    return false;
+  }
+  auto buf = m_buf->GetBuffer();
+  return buf.size() >= 12 &&
+         std::string_view{reinterpret_cast<const char*>(buf.data()), 6} ==
+             "WPILOG" &&
+         wpi::support::endian::read16le(&buf[6]) >= 0x0100;
+}
+
+uint16_t DataLogReader::GetVersion() const {
+  if (!m_buf) {
+    return 0;
+  }
+  auto buf = m_buf->GetBuffer();
+  if (buf.size() < 12) {
+    return 0;
+  }
+  return wpi::support::endian::read16le(&buf[6]);
+}
+
+std::string_view DataLogReader::GetExtraHeader() const {
+  if (!m_buf) {
+    return {};
+  }
+  auto buf = m_buf->GetBuffer();
+  if (buf.size() < 8) {
+    return {};
+  }
+  std::string_view rv;
+  buf = buf.subspan(8);
+  ReadString(&buf, &rv);
+  return rv;
+}
+
+DataLogReader::iterator DataLogReader::begin() const {
+  if (!m_buf) {
+    return end();
+  }
+  auto buf = m_buf->GetBuffer();
+  if (buf.size() < 12) {
+    return end();
+  }
+  uint32_t size = wpi::support::endian::read32le(&buf[8]);
+  if (buf.size() < (12 + size)) {
+    return end();
+  }
+  return DataLogIterator{this, 12 + size};
+}
+
+static uint64_t ReadVarInt(std::span<const uint8_t> buf) {
+  uint64_t val = 0;
+  int shift = 0;
+  for (auto v : buf) {
+    val |= static_cast<uint64_t>(v) << shift;
+    shift += 8;
+  }
+  return val;
+}
+
+bool DataLogReader::GetRecord(size_t* pos, DataLogRecord* out) const {
+  if (!m_buf) {
+    return false;
+  }
+  auto buf = m_buf->GetBuffer();
+  if (*pos >= buf.size()) {
+    return false;
+  }
+  buf = buf.subspan(*pos);
+  if (buf.size() < 4) {  // minimum header length
+    return false;
+  }
+  unsigned int entryLen = (buf[0] & 0x3) + 1;
+  unsigned int sizeLen = ((buf[0] >> 2) & 0x3) + 1;
+  unsigned int timestampLen = ((buf[0] >> 4) & 0x7) + 1;
+  unsigned int headerLen = 1 + entryLen + sizeLen + timestampLen;
+  if (buf.size() < headerLen) {
+    return false;
+  }
+  int entry = ReadVarInt(buf.subspan(1, entryLen));
+  uint32_t size = ReadVarInt(buf.subspan(1 + entryLen, sizeLen));
+  if (size > (buf.size() - headerLen)) {
+    return false;
+  }
+  int64_t timestamp =
+      ReadVarInt(buf.subspan(1 + entryLen + sizeLen, timestampLen));
+  *out = DataLogRecord{entry, timestamp, buf.subspan(headerLen, size)};
+  *pos += headerLen + size;
+  return true;
+}
+
+bool DataLogReader::GetNextRecord(size_t* pos) const {
+  if (!m_buf) {
+    return false;
+  }
+  auto buf = m_buf->GetBuffer();
+  if (buf.size() < (*pos + 4)) {  // minimum header length
+    return false;
+  }
+  unsigned int entryLen = (buf[*pos] & 0x3) + 1;
+  unsigned int sizeLen = ((buf[*pos] >> 2) & 0x3) + 1;
+  unsigned int timestampLen = ((buf[*pos] >> 4) & 0x7) + 1;
+  unsigned int headerLen = 1 + entryLen + sizeLen + timestampLen;
+  if (buf.size() < (*pos + headerLen)) {
+    return false;
+  }
+  uint32_t size = ReadVarInt(buf.subspan(*pos + 1 + entryLen, sizeLen));
+  // check this way to avoid overflow
+  if (size >= (buf.size() - *pos - headerLen)) {
+    return false;
+  }
+  *pos += headerLen + size;
+  return true;
+}
diff --git a/wpiutil/src/main/native/cpp/DsClient.cpp b/wpiutil/src/main/native/cpp/DsClient.cpp
deleted file mode 100644
index 455f10c..0000000
--- a/wpiutil/src/main/native/cpp/DsClient.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/DsClient.h"
-
-#include <fmt/format.h>
-#include <wpi/StringExtras.h>
-#include <wpi/json.h>
-#include <wpi/uv/Tcp.h>
-#include <wpi/uv/Timer.h>
-
-#include "wpi/Logger.h"
-
-using namespace wpi;
-
-static constexpr uv::Timer::Time kReconnectTime{500};
-
-DsClient::DsClient(wpi::uv::Loop& loop, wpi::Logger& logger,
-                   const private_init&)
-    : m_logger{logger},
-      m_tcp{uv::Tcp::Create(loop)},
-      m_timer{uv::Timer::Create(loop)} {
-  m_tcp->end.connect([this] {
-    WPI_DEBUG4(m_logger, "{}", "DS connection closed");
-    clearIp();
-    // try to connect again
-    m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
-  });
-  m_tcp->data.connect([this](wpi::uv::Buffer buf, size_t len) {
-    HandleIncoming({buf.base, len});
-  });
-  m_timer->timeout.connect([this] { Connect(); });
-  Connect();
-}
-
-DsClient::~DsClient() = default;
-
-void DsClient::Close() {
-  m_tcp->Close();
-  m_timer->Close();
-  clearIp();
-}
-
-void DsClient::Connect() {
-  auto connreq = std::make_shared<uv::TcpConnectReq>();
-  connreq->connected.connect([this] {
-    m_json.clear();
-    m_tcp->StopRead();
-    m_tcp->StartRead();
-  });
-
-  connreq->error = [this](uv::Error err) {
-    WPI_DEBUG4(m_logger, "DS connect failure: {}", err.str());
-    // try to connect again
-    m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
-  };
-
-  WPI_DEBUG4(m_logger, "{}", "Starting DS connection attempt");
-  m_tcp->Connect("127.0.0.1", 1742, connreq);
-}
-
-void DsClient::HandleIncoming(std::string_view in) {
-  // this is very bare-bones, as there are never nested {} in these messages
-  while (!in.empty()) {
-    // if json is empty, look for the first { (and discard)
-    if (m_json.empty()) {
-      auto start = in.find('{');
-      in = wpi::slice(in, start, std::string_view::npos);
-    }
-
-    // look for the terminating } (and save)
-    auto end = in.find('}');
-    if (end == std::string_view::npos) {
-      m_json.append(in);
-      return;  // nothing left to read
-    }
-
-    // have complete json message
-    ++end;
-    m_json.append(wpi::slice(in, 0, end));
-    in = wpi::slice(in, end, std::string_view::npos);
-    ParseJson();
-    m_json.clear();
-  }
-}
-
-void DsClient::ParseJson() {
-  WPI_DEBUG4(m_logger, "DsClient JSON: {}", m_json);
-  unsigned int ip = 0;
-  try {
-    ip = wpi::json::parse(m_json).at("robotIP").get<unsigned int>();
-  } catch (wpi::json::exception& e) {
-    WPI_INFO(m_logger, "DsClient JSON error: {}", e.what());
-    return;
-  }
-
-  if (ip == 0) {
-    clearIp();
-  } else {
-    // Convert number into dotted quad
-    auto newip = fmt::format("{}.{}.{}.{}", (ip >> 24) & 0xff,
-                             (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
-    WPI_INFO(m_logger, "DS received server IP: {}", newip);
-    setIp(newip);
-  }
-}
diff --git a/wpiutil/src/main/native/cpp/EventLoopRunner.cpp b/wpiutil/src/main/native/cpp/EventLoopRunner.cpp
deleted file mode 100644
index c86176e..0000000
--- a/wpiutil/src/main/native/cpp/EventLoopRunner.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/EventLoopRunner.h"
-
-#include "wpi/SmallVector.h"
-#include "wpi/condition_variable.h"
-#include "wpi/mutex.h"
-#include "wpi/uv/AsyncFunction.h"
-#include "wpi/uv/Loop.h"
-
-using namespace wpi;
-
-class EventLoopRunner::Thread : public SafeThread {
- public:
-  using UvExecFunc = uv::AsyncFunction<void(LoopFunc)>;
-
-  Thread() : m_loop(uv::Loop::Create()) {
-    // set up async handles
-    if (!m_loop) {
-      return;
-    }
-
-    // run function
-    m_doExec = UvExecFunc::Create(
-        m_loop, [loop = m_loop.get()](auto out, LoopFunc func) {
-          func(*loop);
-          out.set_value();
-        });
-  }
-
-  void Main() override {
-    if (m_loop) {
-      m_loop->Run();
-    }
-  }
-
-  // the loop
-  std::shared_ptr<uv::Loop> m_loop;
-
-  // run function
-  std::weak_ptr<UvExecFunc> m_doExec;
-};
-
-EventLoopRunner::EventLoopRunner() {
-  m_owner.Start();
-}
-
-EventLoopRunner::~EventLoopRunner() {
-  Stop();
-}
-
-void EventLoopRunner::Stop() {
-  ExecAsync([](uv::Loop& loop) {
-    // close all handles; this will (eventually) stop the loop
-    loop.Walk([](uv::Handle& h) {
-      h.SetLoopClosing(true);
-      h.Close();
-    });
-  });
-  m_owner.Join();
-}
-
-void EventLoopRunner::ExecAsync(LoopFunc func) {
-  if (auto thr = m_owner.GetThread()) {
-    if (auto doExec = thr->m_doExec.lock()) {
-      doExec->Call(std::move(func));
-    }
-  }
-}
-
-void EventLoopRunner::ExecSync(LoopFunc func) {
-  wpi::future<void> f;
-  if (auto thr = m_owner.GetThread()) {
-    if (auto doExec = thr->m_doExec.lock()) {
-      f = doExec->Call(std::move(func));
-    }
-  }
-  if (f.valid()) {
-    f.wait();
-  }
-}
-
-std::shared_ptr<uv::Loop> EventLoopRunner::GetLoop() {
-  if (auto thr = m_owner.GetThread()) {
-    return thr->m_loop;
-  }
-  return nullptr;
-}
diff --git a/wpiutil/src/main/native/cpp/HttpParser.cpp b/wpiutil/src/main/native/cpp/HttpParser.cpp
deleted file mode 100644
index 3c18e0f..0000000
--- a/wpiutil/src/main/native/cpp/HttpParser.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpParser.h"
-
-using namespace wpi;
-
-uint32_t HttpParser::GetParserVersion() {
-  return static_cast<uint32_t>(http_parser_version());
-}
-
-HttpParser::HttpParser(Type type) {
-  http_parser_init(&m_parser,
-                   static_cast<http_parser_type>(static_cast<int>(type)));
-  m_parser.data = this;
-
-  http_parser_settings_init(&m_settings);
-
-  // Unlike the underlying http_parser library, we don't perform callbacks
-  // (other than body) with partial data; instead we buffer and call the user
-  // callback only when the data is complete.
-
-  // on_message_begin: initialize our state, call user callback
-  m_settings.on_message_begin = [](http_parser* p) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    self.m_urlBuf.clear();
-    self.m_state = kStart;
-    self.messageBegin();
-    return self.m_aborted;
-  };
-
-  // on_url: collect into buffer
-  m_settings.on_url = [](http_parser* p, const char* at, size_t length) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    // append to buffer
-    if ((self.m_urlBuf.size() + length) > self.m_maxLength) {
-      return 1;
-    }
-    self.m_urlBuf += std::string_view{at, length};
-    self.m_state = kUrl;
-    return 0;
-  };
-
-  // on_status: collect into buffer, call user URL callback
-  m_settings.on_status = [](http_parser* p, const char* at,
-                            size_t length) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    // use valueBuf for the status
-    if ((self.m_valueBuf.size() + length) > self.m_maxLength) {
-      return 1;
-    }
-    self.m_valueBuf += std::string_view{at, length};
-    self.m_state = kStatus;
-    return 0;
-  };
-
-  // on_header_field: collect into buffer, call user header/status callback
-  m_settings.on_header_field = [](http_parser* p, const char* at,
-                                  size_t length) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-
-    // once we're in header, we know the URL is complete
-    if (self.m_state == kUrl) {
-      self.url(self.m_urlBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    // once we're in header, we know the status is complete
-    if (self.m_state == kStatus) {
-      self.status(self.m_valueBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    // if we previously were in value state, that means we finished a header
-    if (self.m_state == kValue) {
-      self.header(self.m_fieldBuf, self.m_valueBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    // clear field and value when we enter this state
-    if (self.m_state != kField) {
-      self.m_state = kField;
-      self.m_fieldBuf.clear();
-      self.m_valueBuf.clear();
-    }
-
-    // append data to field buffer
-    if ((self.m_fieldBuf.size() + length) > self.m_maxLength) {
-      return 1;
-    }
-    self.m_fieldBuf += std::string_view{at, length};
-    return 0;
-  };
-
-  // on_header_field: collect into buffer
-  m_settings.on_header_value = [](http_parser* p, const char* at,
-                                  size_t length) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-
-    // if we weren't previously in value state, clear the buffer
-    if (self.m_state != kValue) {
-      self.m_state = kValue;
-      self.m_valueBuf.clear();
-    }
-
-    // append data to value buffer
-    if ((self.m_valueBuf.size() + length) > self.m_maxLength) {
-      return 1;
-    }
-    self.m_valueBuf += std::string_view{at, length};
-    return 0;
-  };
-
-  // on_headers_complete: call user status/header/complete callback
-  m_settings.on_headers_complete = [](http_parser* p) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-
-    // if we previously were in url state, that means we finished the url
-    if (self.m_state == kUrl) {
-      self.url(self.m_urlBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    // if we previously were in status state, that means we finished the status
-    if (self.m_state == kStatus) {
-      self.status(self.m_valueBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    // if we previously were in value state, that means we finished a header
-    if (self.m_state == kValue) {
-      self.header(self.m_fieldBuf, self.m_valueBuf);
-      if (self.m_aborted) {
-        return 1;
-      }
-    }
-
-    self.headersComplete(self.ShouldKeepAlive());
-    return self.m_aborted;
-  };
-
-  // on_body: call user callback
-  m_settings.on_body = [](http_parser* p, const char* at,
-                          size_t length) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    self.body(std::string_view{at, length}, self.IsBodyFinal());
-    return self.m_aborted;
-  };
-
-  // on_message_complete: call user callback
-  m_settings.on_message_complete = [](http_parser* p) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    self.messageComplete(self.ShouldKeepAlive());
-    return self.m_aborted;
-  };
-
-  // on_chunk_header: call user callback
-  m_settings.on_chunk_header = [](http_parser* p) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    self.chunkHeader(p->content_length);
-    return self.m_aborted;
-  };
-
-  // on_chunk_complete: call user callback
-  m_settings.on_chunk_complete = [](http_parser* p) -> int {
-    auto& self = *static_cast<HttpParser*>(p->data);
-    self.chunkComplete();
-    return self.m_aborted;
-  };
-}
-
-void HttpParser::Reset(Type type) {
-  http_parser_init(&m_parser,
-                   static_cast<http_parser_type>(static_cast<int>(type)));
-  m_parser.data = this;
-  m_maxLength = 1024;
-  m_state = kStart;
-  m_urlBuf.clear();
-  m_fieldBuf.clear();
-  m_valueBuf.clear();
-  m_aborted = false;
-}
diff --git a/wpiutil/src/main/native/cpp/HttpServerConnection.cpp b/wpiutil/src/main/native/cpp/HttpServerConnection.cpp
deleted file mode 100644
index 716d2af..0000000
--- a/wpiutil/src/main/native/cpp/HttpServerConnection.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpServerConnection.h"
-
-#include "fmt/format.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/SpanExtras.h"
-#include "wpi/StringExtras.h"
-#include "wpi/fmt/raw_ostream.h"
-#include "wpi/raw_uv_ostream.h"
-
-using namespace wpi;
-
-HttpServerConnection::HttpServerConnection(std::shared_ptr<uv::Stream> stream)
-    : m_stream(*stream) {
-  // process HTTP messages
-  m_messageCompleteConn =
-      m_request.messageComplete.connect_connection([this](bool keepAlive) {
-        m_keepAlive = keepAlive;
-        ProcessRequest();
-      });
-
-  // look for Accept-Encoding headers to determine if gzip is acceptable
-  m_request.messageBegin.connect([this] { m_acceptGzip = false; });
-  m_request.header.connect(
-      [this](std::string_view name, std::string_view value) {
-        if (wpi::equals_lower(name, "accept-encoding") &&
-            wpi::contains(value, "gzip")) {
-          m_acceptGzip = true;
-        }
-      });
-
-  // pass incoming data to HTTP parser
-  m_dataConn =
-      stream->data.connect_connection([this](uv::Buffer& buf, size_t size) {
-        m_request.Execute({buf.base, size});
-        if (m_request.HasError()) {
-          // could not parse; just close the connection
-          m_stream.Close();
-        }
-      });
-
-  // close when remote side closes
-  m_endConn =
-      stream->end.connect_connection([h = stream.get()] { h->Close(); });
-
-  // start reading
-  stream->StartRead();
-}
-
-void HttpServerConnection::BuildCommonHeaders(raw_ostream& os) {
-  os << "Server: WebServer/1.0\r\n"
-        "Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, "
-        "post-check=0, max-age=0\r\n"
-        "Pragma: no-cache\r\n"
-        "Expires: Mon, 3 Jan 2000 12:34:56 GMT\r\n";
-}
-
-void HttpServerConnection::BuildHeader(raw_ostream& os, int code,
-                                       std::string_view codeText,
-                                       std::string_view contentType,
-                                       uint64_t contentLength,
-                                       std::string_view extra) {
-  fmt::print(os, "HTTP/{}.{} {} {}\r\n", m_request.GetMajor(),
-             m_request.GetMinor(), code, codeText);
-  if (contentLength == 0) {
-    m_keepAlive = false;
-  }
-  if (!m_keepAlive) {
-    os << "Connection: close\r\n";
-  }
-  BuildCommonHeaders(os);
-  os << "Content-Type: " << contentType << "\r\n";
-  if (contentLength != 0) {
-    fmt::print(os, "Content-Length: {}\r\n", contentLength);
-  }
-  os << "Access-Control-Allow-Origin: *\r\nAccess-Control-Allow-Methods: *\r\n";
-  if (!extra.empty()) {
-    os << extra;
-  }
-  os << "\r\n";  // header ends with a blank line
-}
-
-void HttpServerConnection::SendData(span<const uv::Buffer> bufs,
-                                    bool closeAfter) {
-  m_stream.Write(bufs, [closeAfter, stream = &m_stream](auto bufs, uv::Error) {
-    for (auto&& buf : bufs) {
-      buf.Deallocate();
-    }
-    if (closeAfter) {
-      stream->Close();
-    }
-  });
-}
-
-void HttpServerConnection::SendResponse(int code, std::string_view codeText,
-                                        std::string_view contentType,
-                                        std::string_view content,
-                                        std::string_view extraHeader) {
-  SmallVector<uv::Buffer, 4> toSend;
-  raw_uv_ostream os{toSend, 4096};
-  BuildHeader(os, code, codeText, contentType, content.size(), extraHeader);
-  os << content;
-  // close after write completes if we aren't keeping alive
-  SendData(os.bufs(), !m_keepAlive);
-}
-
-void HttpServerConnection::SendStaticResponse(
-    int code, std::string_view codeText, std::string_view contentType,
-    std::string_view content, bool gzipped, std::string_view extraHeader) {
-  // TODO: handle remote side not accepting gzip (very rare)
-
-  std::string_view contentEncodingHeader;
-  if (gzipped /* && m_acceptGzip*/) {
-    contentEncodingHeader = "Content-Encoding: gzip\r\n";
-  }
-
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, 4096};
-  BuildHeader(os, code, codeText, contentType, content.size(),
-              fmt::format("{}{}", extraHeader, contentEncodingHeader));
-  // can send content without copying
-  bufs.emplace_back(content);
-
-  m_stream.Write(bufs, [closeAfter = !m_keepAlive, stream = &m_stream](
-                           auto bufs, uv::Error) {
-    // don't deallocate the static content
-    for (auto&& buf : wpi::drop_back(bufs)) {
-      buf.Deallocate();
-    }
-    if (closeAfter) {
-      stream->Close();
-    }
-  });
-}
-
-void HttpServerConnection::SendError(int code, std::string_view message) {
-  std::string_view codeText, extra, baseMessage;
-  switch (code) {
-    case 401:
-      codeText = "Unauthorized";
-      extra = "WWW-Authenticate: Basic realm=\"CameraServer\"";
-      baseMessage = "401: Not Authenticated!";
-      break;
-    case 404:
-      codeText = "Not Found";
-      baseMessage = "404: Not Found!";
-      break;
-    case 500:
-      codeText = "Internal Server Error";
-      baseMessage = "500: Internal Server Error!";
-      break;
-    case 400:
-      codeText = "Bad Request";
-      baseMessage = "400: Not Found!";
-      break;
-    case 403:
-      codeText = "Forbidden";
-      baseMessage = "403: Forbidden!";
-      break;
-    case 503:
-      codeText = "Service Unavailable";
-      baseMessage = "503: Service Unavailable";
-      break;
-    default:
-      code = 501;
-      codeText = "Not Implemented";
-      baseMessage = "501: Not Implemented!";
-      break;
-  }
-  SmallString<256> content{baseMessage};
-  content += "\r\n";
-  content += message;
-  SendResponse(code, codeText, "text/plain", content.str(), extra);
-}
diff --git a/wpiutil/src/main/native/cpp/HttpUtil.cpp b/wpiutil/src/main/native/cpp/HttpUtil.cpp
deleted file mode 100644
index b8b7cc8..0000000
--- a/wpiutil/src/main/native/cpp/HttpUtil.cpp
+++ /dev/null
@@ -1,493 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpUtil.h"
-
-#include <cctype>
-
-#include "fmt/format.h"
-#include "wpi/Base64.h"
-#include "wpi/StringExtras.h"
-#include "wpi/TCPConnector.h"
-#include "wpi/raw_ostream.h"
-
-namespace wpi {
-
-std::string_view UnescapeURI(std::string_view str, SmallVectorImpl<char>& buf,
-                             bool* error) {
-  buf.clear();
-  for (auto i = str.begin(), end = str.end(); i != end; ++i) {
-    // pass non-escaped characters to output
-    if (*i != '%') {
-      // decode + to space
-      if (*i == '+') {
-        buf.push_back(' ');
-      } else {
-        buf.push_back(*i);
-      }
-      continue;
-    }
-
-    // are there enough characters left?
-    if (i + 2 >= end) {
-      *error = true;
-      return {};
-    }
-
-    // replace %xx with the corresponding character
-    unsigned val1 = hexDigitValue(*++i);
-    if (val1 == -1U) {
-      *error = true;
-      return {};
-    }
-    unsigned val2 = hexDigitValue(*++i);
-    if (val2 == -1U) {
-      *error = true;
-      return {};
-    }
-    buf.push_back((val1 << 4) | val2);
-  }
-
-  *error = false;
-  return {buf.data(), buf.size()};
-}
-
-std::string_view EscapeURI(std::string_view str, SmallVectorImpl<char>& buf,
-                           bool spacePlus) {
-  static const char* const hexLut = "0123456789ABCDEF";
-
-  buf.clear();
-  for (auto i = str.begin(), end = str.end(); i != end; ++i) {
-    // pass unreserved characters to output
-    if (std::isalnum(*i) || *i == '-' || *i == '_' || *i == '.' || *i == '~') {
-      buf.push_back(*i);
-      continue;
-    }
-
-    // encode space to +
-    if (spacePlus && *i == ' ') {
-      buf.push_back('+');
-      continue;
-    }
-
-    // convert others to %xx
-    buf.push_back('%');
-    buf.push_back(hexLut[((*i) >> 4) & 0x0f]);
-    buf.push_back(hexLut[(*i) & 0x0f]);
-  }
-
-  return {buf.data(), buf.size()};
-}
-
-HttpQueryMap::HttpQueryMap(std::string_view query) {
-  SmallVector<std::string_view, 16> queryElems;
-  split(query, queryElems, '&', 100, false);
-  for (auto elem : queryElems) {
-    auto [nameEsc, valueEsc] = split(elem, '=');
-    SmallString<64> nameBuf;
-    bool err = false;
-    auto name = wpi::UnescapeURI(nameEsc, nameBuf, &err);
-    // note: ignores duplicates
-    if (!err) {
-      m_elems.try_emplace(name, valueEsc);
-    }
-  }
-}
-
-std::optional<std::string_view> HttpQueryMap::Get(
-    std::string_view name, wpi::SmallVectorImpl<char>& buf) const {
-  auto it = m_elems.find(name);
-  if (it == m_elems.end()) {
-    return {};
-  }
-  bool err = false;
-  auto val = wpi::UnescapeURI(it->second, buf, &err);
-  if (err) {
-    return {};
-  }
-  return val;
-}
-
-HttpPath::HttpPath(std::string_view path) {
-  // special-case root path to be a single empty element
-  if (path == "/") {
-    m_pathEnds.emplace_back(0);
-    return;
-  }
-  wpi::SmallVector<std::string_view, 16> pathElems;
-  split(path, pathElems, '/', 100, false);
-  for (auto elem : pathElems) {
-    SmallString<64> buf;
-    bool err = false;
-    auto val = wpi::UnescapeURI(elem, buf, &err);
-    if (err) {
-      m_pathEnds.clear();
-      return;
-    }
-    m_pathBuf += val;
-    m_pathEnds.emplace_back(m_pathBuf.size());
-  }
-}
-
-bool HttpPath::startswith(size_t start,
-                          span<const std::string_view> match) const {
-  if (m_pathEnds.size() < (start + match.size())) {
-    return false;
-  }
-  bool first = start == 0;
-  auto p = m_pathEnds.begin() + start;
-  for (auto m : match) {
-    auto val = slice(m_pathBuf, first ? 0 : *(p - 1), *p);
-    if (val != m) {
-      return false;
-    }
-    first = false;
-    ++p;
-  }
-  return true;
-}
-
-std::string_view HttpPath::operator[](size_t n) const {
-  return slice(m_pathBuf, n == 0 ? 0 : m_pathEnds[n - 1], m_pathEnds[n]);
-}
-
-bool ParseHttpHeaders(raw_istream& is, SmallVectorImpl<char>* contentType,
-                      SmallVectorImpl<char>* contentLength) {
-  if (contentType) {
-    contentType->clear();
-  }
-  if (contentLength) {
-    contentLength->clear();
-  }
-
-  bool inContentType = false;
-  bool inContentLength = false;
-  SmallString<64> lineBuf;
-  for (;;) {
-    std::string_view line = rtrim(is.getline(lineBuf, 1024));
-    if (is.has_error()) {
-      return false;
-    }
-    if (line.empty()) {
-      return true;  // empty line signals end of headers
-    }
-
-    // header fields start at the beginning of the line
-    if (!std::isspace(line[0])) {
-      inContentType = false;
-      inContentLength = false;
-      std::string_view field;
-      std::tie(field, line) = split(line, ':');
-      field = rtrim(field);
-      if (equals_lower(field, "content-type")) {
-        inContentType = true;
-      } else if (equals_lower(field, "content-length")) {
-        inContentLength = true;
-      } else {
-        continue;  // ignore other fields
-      }
-    }
-
-    // collapse whitespace
-    line = ltrim(line);
-
-    // save field data
-    if (inContentType && contentType) {
-      contentType->append(line.begin(), line.end());
-    } else if (inContentLength && contentLength) {
-      contentLength->append(line.begin(), line.end());
-    }
-  }
-}
-
-bool FindMultipartBoundary(raw_istream& is, std::string_view boundary,
-                           std::string* saveBuf) {
-  SmallString<64> searchBuf;
-  searchBuf.resize(boundary.size() + 2);
-  size_t searchPos = 0;
-
-  // Per the spec, the --boundary should be preceded by \r\n, so do a first
-  // pass of 1-byte reads to throw those away (common case) and keep the
-  // last non-\r\n character in searchBuf.
-  if (!saveBuf) {
-    do {
-      is.read(searchBuf.data(), 1);
-      if (is.has_error()) {
-        return false;
-      }
-    } while (searchBuf[0] == '\r' || searchBuf[0] == '\n');
-    searchPos = 1;
-  }
-
-  // Look for --boundary.  Read boundarysize+2 bytes at a time
-  // during the search to speed up the reads, then fast-scan for -,
-  // and only then match the entire boundary.  This will be slow if
-  // there's a bunch of continuous -'s in the output, but that's unlikely.
-  for (;;) {
-    is.read(searchBuf.data() + searchPos, searchBuf.size() - searchPos);
-    if (is.has_error()) {
-      return false;
-    }
-
-    // Did we find the boundary?
-    if (searchBuf[0] == '-' && searchBuf[1] == '-' &&
-        wpi::substr(searchBuf, 2) == boundary) {
-      return true;
-    }
-
-    // Fast-scan for '-'
-    size_t pos = searchBuf.find('-', searchBuf[0] == '-' ? 1 : 0);
-    if (pos == std::string_view::npos) {
-      if (saveBuf) {
-        saveBuf->append(searchBuf.data(), searchBuf.size());
-      }
-    } else {
-      if (saveBuf) {
-        saveBuf->append(searchBuf.data(), pos);
-      }
-
-      // move '-' and following to start of buffer (next read will fill)
-      std::memmove(searchBuf.data(), searchBuf.data() + pos,
-                   searchBuf.size() - pos);
-      searchPos = searchBuf.size() - pos;
-    }
-  }
-}
-
-HttpLocation::HttpLocation(std::string_view url_, bool* error,
-                           std::string* errorMsg)
-    : url{url_} {
-  // Split apart into components
-  std::string_view query{url};
-
-  // scheme:
-  std::string_view scheme;
-  std::tie(scheme, query) = split(query, ':');
-  if (!equals_lower(scheme, "http")) {
-    *errorMsg = "only supports http URLs";
-    *error = true;
-    return;
-  }
-
-  // "//"
-  if (!starts_with(query, "//")) {
-    *errorMsg = "expected http://...";
-    *error = true;
-    return;
-  }
-  query.remove_prefix(2);
-
-  // user:password@host:port/
-  std::string_view authority;
-  std::tie(authority, query) = split(query, '/');
-
-  auto [userpass, hostport] = split(authority, '@');
-  // split leaves the RHS empty if the split char isn't present...
-  if (hostport.empty()) {
-    hostport = userpass;
-    userpass = {};
-  }
-
-  if (!userpass.empty()) {
-    auto [rawUser, rawPassword] = split(userpass, ':');
-    SmallString<64> userBuf, passBuf;
-    user = UnescapeURI(rawUser, userBuf, error);
-    if (*error) {
-      *errorMsg = fmt::format("could not unescape user \"{}\"", rawUser);
-      return;
-    }
-    password = UnescapeURI(rawPassword, passBuf, error);
-    if (*error) {
-      *errorMsg =
-          fmt::format("could not unescape password \"{}\"", rawPassword);
-      return;
-    }
-  }
-
-  std::string_view portStr;
-  std::tie(host, portStr) = rsplit(hostport, ':');
-  if (host.empty()) {
-    *errorMsg = "host is empty";
-    *error = true;
-    return;
-  }
-  if (portStr.empty()) {
-    port = 80;
-  } else if (auto p = parse_integer<int>(portStr, 10)) {
-    port = p.value();
-  } else {
-    *errorMsg = fmt::format("port \"{}\" is not an integer", portStr);
-    *error = true;
-    return;
-  }
-
-  // path?query#fragment
-  std::tie(query, fragment) = split(query, '#');
-  std::tie(path, query) = split(query, '?');
-
-  // Split query string into parameters
-  while (!query.empty()) {
-    // split out next param and value
-    std::string_view rawParam, rawValue;
-    std::tie(rawParam, query) = split(query, '&');
-    if (rawParam.empty()) {
-      continue;  // ignore "&&"
-    }
-    std::tie(rawParam, rawValue) = split(rawParam, '=');
-
-    // unescape param
-    *error = false;
-    SmallString<64> paramBuf;
-    std::string_view param = UnescapeURI(rawParam, paramBuf, error);
-    if (*error) {
-      *errorMsg = fmt::format("could not unescape parameter \"{}\"", rawParam);
-      return;
-    }
-
-    // unescape value
-    SmallString<64> valueBuf;
-    std::string_view value = UnescapeURI(rawValue, valueBuf, error);
-    if (*error) {
-      *errorMsg = fmt::format("could not unescape value \"{}\"", rawValue);
-      return;
-    }
-
-    params.emplace_back(std::make_pair(param, value));
-  }
-
-  *error = false;
-}
-
-void HttpRequest::SetAuth(const HttpLocation& loc) {
-  if (!loc.user.empty()) {
-    SmallString<64> userpass;
-    userpass += loc.user;
-    userpass += ':';
-    userpass += loc.password;
-    Base64Encode(userpass.str(), &auth);
-  }
-}
-
-bool HttpConnection::Handshake(const HttpRequest& request,
-                               std::string* warnMsg) {
-  // send GET request
-  os << "GET /" << request.path << " HTTP/1.1\r\n";
-  os << "Host: " << request.host << "\r\n";
-  if (!request.auth.empty()) {
-    os << "Authorization: Basic " << request.auth << "\r\n";
-  }
-  os << "\r\n";
-  os.flush();
-
-  // read first line of response
-  SmallString<64> lineBuf;
-  std::string_view line = rtrim(is.getline(lineBuf, 1024));
-  if (is.has_error()) {
-    *warnMsg = "disconnected before response";
-    return false;
-  }
-
-  // see if we got a HTTP 200 response
-  std::string_view httpver, code, codeText;
-  std::tie(httpver, line) = split(line, ' ');
-  std::tie(code, codeText) = split(line, ' ');
-  if (!starts_with(httpver, "HTTP")) {
-    *warnMsg = "did not receive HTTP response";
-    return false;
-  }
-  if (code != "200") {
-    *warnMsg = fmt::format("received {} {} response", code, codeText);
-    return false;
-  }
-
-  // Parse headers
-  if (!ParseHttpHeaders(is, &contentType, &contentLength)) {
-    *warnMsg = "disconnected during headers";
-    return false;
-  }
-
-  return true;
-}
-
-void HttpMultipartScanner::SetBoundary(std::string_view boundary) {
-  m_boundaryWith = "\n--";
-  m_boundaryWith += boundary;
-  m_boundaryWithout = "\n";
-  m_boundaryWithout += boundary;
-  m_dashes = kUnknown;
-}
-
-void HttpMultipartScanner::Reset(bool saveSkipped) {
-  m_saveSkipped = saveSkipped;
-  m_state = kBoundary;
-  m_posWith = 0;
-  m_posWithout = 0;
-  m_buf.resize(0);
-}
-
-std::string_view HttpMultipartScanner::Execute(std::string_view in) {
-  if (m_state == kDone) {
-    Reset(m_saveSkipped);
-  }
-  if (m_saveSkipped) {
-    m_buf += in;
-  }
-
-  size_t pos = 0;
-  if (m_state == kBoundary) {
-    for (char ch : in) {
-      ++pos;
-      if (m_dashes != kWithout) {
-        if (ch == m_boundaryWith[m_posWith]) {
-          ++m_posWith;
-          if (m_posWith == m_boundaryWith.size()) {
-            // Found the boundary; transition to padding
-            m_state = kPadding;
-            m_dashes = kWith;  // no longer accept plain 'boundary'
-            break;
-          }
-        } else if (ch == m_boundaryWith[0]) {
-          m_posWith = 1;
-        } else {
-          m_posWith = 0;
-        }
-      }
-
-      if (m_dashes != kWith) {
-        if (ch == m_boundaryWithout[m_posWithout]) {
-          ++m_posWithout;
-          if (m_posWithout == m_boundaryWithout.size()) {
-            // Found the boundary; transition to padding
-            m_state = kPadding;
-            m_dashes = kWithout;  // no longer accept '--boundary'
-            break;
-          }
-        } else if (ch == m_boundaryWithout[0]) {
-          m_posWithout = 1;
-        } else {
-          m_posWithout = 0;
-        }
-      }
-    }
-  }
-
-  if (m_state == kPadding) {
-    for (char ch : drop_front(in, pos)) {
-      ++pos;
-      if (ch == '\n') {
-        // Found the LF; return remaining input buffer (following it)
-        m_state = kDone;
-        if (m_saveSkipped) {
-          m_buf.resize(m_buf.size() - in.size() + pos);
-        }
-        return drop_front(in, pos);
-      }
-    }
-  }
-
-  // We consumed the entire input
-  return {};
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/MappedFileRegion.cpp b/wpiutil/src/main/native/cpp/MappedFileRegion.cpp
new file mode 100644
index 0000000..006e395
--- /dev/null
+++ b/wpiutil/src/main/native/cpp/MappedFileRegion.cpp
@@ -0,0 +1,133 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/MappedFileRegion.h"
+
+#include <sys/types.h>
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>  // NOLINT(build/include_order)
+
+#include <memoryapi.h>
+#include <sysinfoapi.h>
+
+#else  // _WIN32
+
+#include <sys/mman.h>
+#include <unistd.h>
+
+#endif  // _WIN32
+
+#ifdef _MSC_VER
+#include <io.h>
+#endif
+
+#ifdef _WIN32
+#include "wpi/WindowsError.h"
+#endif
+
+using namespace wpi;
+
+MappedFileRegion::MappedFileRegion(fs::file_t f, uint64_t length,
+                                   uint64_t offset, MapMode mapMode,
+                                   std::error_code& ec)
+    : m_size(length) {
+#ifdef _WIN32
+  if (f == INVALID_HANDLE_VALUE) {
+    ec = std::make_error_code(std::errc::bad_file_descriptor);
+    return;
+  }
+
+  HANDLE fileMappingHandle = ::CreateFileMappingW(
+      f, 0, mapMode == kReadOnly ? PAGE_READONLY : PAGE_READWRITE, length >> 32,
+      length & 0xffffffff, 0);
+  if (fileMappingHandle == nullptr) {
+    ec = wpi::mapWindowsError(GetLastError());
+    return;
+  }
+
+  DWORD dwDesiredAccess = 0;
+  switch (mapMode) {
+    case kReadOnly:
+      dwDesiredAccess = FILE_MAP_READ;
+      break;
+    case kReadWrite:
+      dwDesiredAccess = FILE_MAP_WRITE;
+      break;
+    case kPriv:
+      dwDesiredAccess = FILE_MAP_WRITE | FILE_MAP_COPY;
+      break;
+  }
+  m_mapping = ::MapViewOfFile(fileMappingHandle, dwDesiredAccess, offset >> 32,
+                              offset & 0xffffffff, length);
+  if (m_mapping == nullptr) {
+    ec = wpi::mapWindowsError(GetLastError());
+    ::CloseHandle(fileMappingHandle);
+    return;
+  }
+
+  // Close the file mapping handle, as it's kept alive by the file mapping. But
+  // neither the file mapping nor the file mapping handle keep the file handle
+  // alive, so we need to keep a reference to the file in case all other handles
+  // are closed and the file is deleted, which may cause invalid data to be read
+  // from the file.
+  ::CloseHandle(fileMappingHandle);
+  if (!::DuplicateHandle(::GetCurrentProcess(), f, ::GetCurrentProcess(),
+                         &m_fileHandle, 0, 0, DUPLICATE_SAME_ACCESS)) {
+    ec = wpi::mapWindowsError(GetLastError());
+    ::UnmapViewOfFile(m_mapping);
+    m_mapping = nullptr;
+    return;
+  }
+#else
+  m_mapping =
+      ::mmap(nullptr, length,
+             mapMode == kReadOnly ? PROT_READ : (PROT_READ | PROT_WRITE),
+             mapMode == kPriv ? MAP_PRIVATE : MAP_SHARED, f, offset);
+  if (m_mapping == MAP_FAILED) {
+    ec = std::error_code(errno, std::generic_category());
+    m_mapping = nullptr;
+  }
+#endif
+}
+
+void MappedFileRegion::Flush() {
+#ifdef _WIN32
+  ::FlushViewOfFile(m_mapping, 0);
+  ::FlushFileBuffers(m_fileHandle);
+#else
+  ::msync(m_mapping, m_size, MS_ASYNC);
+#endif
+}
+
+void MappedFileRegion::Unmap() {
+  if (!m_mapping) {
+    return;
+  }
+#ifdef _WIN32
+  ::UnmapViewOfFile(m_mapping);
+  ::CloseHandle(m_fileHandle);
+#else
+  ::munmap(m_mapping, m_size);
+#endif
+  m_mapping = nullptr;
+}
+
+size_t MappedFileRegion::GetAlignment() {
+#ifdef _WIN32
+  SYSTEM_INFO SysInfo;
+  ::GetSystemInfo(&SysInfo);
+  return SysInfo.dwAllocationGranularity;
+#else
+  static long pageSize = ::getpagesize();  // NOLINT
+  if (pageSize < 0) {
+    pageSize = 4096;
+  }
+  return pageSize;
+#endif
+}
diff --git a/wpiutil/src/main/native/cpp/MessagePack.cpp b/wpiutil/src/main/native/cpp/MessagePack.cpp
new file mode 100644
index 0000000..60a2f01
--- /dev/null
+++ b/wpiutil/src/main/native/cpp/MessagePack.cpp
@@ -0,0 +1,45 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/MessagePack.h"
+
+using namespace mpack;
+
+mpack_error_t mpack::mpack_expect_str(mpack_reader_t* reader, std::string* out,
+                                      uint32_t maxLen) {
+  uint32_t count = mpack_expect_str_max(reader, maxLen);
+  mpack_error_t err = mpack_reader_error(reader);
+  if (err != mpack_ok) {
+    return err;
+  }
+  const char* bytes = mpack_read_bytes_inplace(reader, count);
+  if (bytes) {
+    out->assign(bytes, count);
+  } else {
+    return mpack_reader_error(reader);
+  }
+  mpack_done_str(reader);
+  return mpack_ok;
+}
+
+mpack_error_t mpack::mpack_read_str(mpack_reader_t* reader, mpack_tag_t* tag,
+                                    std::string* out, uint32_t maxLen) {
+  uint32_t count = mpack_tag_str_length(tag);
+  mpack_error_t err = mpack_reader_error(reader);
+  if (err != mpack_ok) {
+    return err;
+  }
+  if (count > maxLen) {
+    mpack_reader_flag_error(reader, mpack_error_too_big);
+    return mpack_error_too_big;
+  }
+  const char* bytes = mpack_read_bytes_inplace(reader, count);
+  if (bytes) {
+    out->assign(bytes, count);
+  } else {
+    return mpack_reader_error(reader);
+  }
+  mpack_done_str(reader);
+  return mpack_ok;
+}
diff --git a/wpiutil/src/main/native/cpp/MimeTypes.cpp b/wpiutil/src/main/native/cpp/MimeTypes.cpp
deleted file mode 100644
index 5f5bf59..0000000
--- a/wpiutil/src/main/native/cpp/MimeTypes.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MimeTypes.h"
-
-#include "wpi/StringExtras.h"
-#include "wpi/StringMap.h"
-
-namespace wpi {
-
-// derived partially from
-// https://github.com/DEGoodmanWilson/libmime/blob/stable/0.1.2/mime/mime.cpp
-std::string_view MimeTypeFromPath(std::string_view path) {
-  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
-  static StringMap<const char*> mimeTypes{
-      // text
-      {"css", "text/css"},
-      {"csv", "text/csv"},
-      {"htm", "text/html"},
-      {"html", "text/html"},
-      {"js", "text/javascript"},
-      {"json", "application/json"},
-      {"map", "application/json"},
-      {"md", "text/markdown"},
-      {"txt", "text/plain"},
-      {"xml", "text/xml"},
-
-      // images
-      {"apng", "image/apng"},
-      {"bmp", "image/bmp"},
-      {"gif", "image/gif"},
-      {"cur", "image/x-icon"},
-      {"ico", "image/x-icon"},
-      {"jpg", "image/jpeg"},
-      {"jpeg", "image/jpeg"},
-      {"png", "image/png"},
-      {"svg", "image/svg+xml"},
-      {"tif", "image/tiff"},
-      {"tiff", "image/tiff"},
-      {"webp", "image/webp"},
-
-      // fonts
-      {"otf", "font/otf"},
-      {"ttf", "font/ttf"},
-      {"woff", "font/woff"},
-
-      // misc
-      {"pdf", "application/pdf"},
-      {"zip", "application/zip"},
-  };
-
-  static const char* defaultType = "application/octet-stream";
-
-  auto pos = path.find_last_of("/");
-  if (pos != std::string_view::npos) {
-    path = wpi::substr(path, pos + 1);
-  }
-  auto dot_pos = path.find_last_of(".");
-  if (dot_pos > 0 && dot_pos != std::string_view::npos) {
-    auto type = mimeTypes.find(wpi::substr(path, dot_pos + 1));
-    if (type != mimeTypes.end()) {
-      return type->getValue();
-    }
-  }
-  return defaultType;
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/MulticastHandleManager.cpp b/wpiutil/src/main/native/cpp/MulticastHandleManager.cpp
deleted file mode 100644
index d249a1c..0000000
--- a/wpiutil/src/main/native/cpp/MulticastHandleManager.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "MulticastHandleManager.h"
-
-using namespace wpi;
-
-MulticastHandleManager& wpi::GetMulticastManager() {
-  static MulticastHandleManager manager;
-  return manager;
-}
diff --git a/wpiutil/src/main/native/cpp/MulticastHandleManager.h b/wpiutil/src/main/native/cpp/MulticastHandleManager.h
deleted file mode 100644
index be8d061..0000000
--- a/wpiutil/src/main/native/cpp/MulticastHandleManager.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <memory>
-
-#include "wpi/DenseMap.h"
-#include "wpi/MulticastServiceAnnouncer.h"
-#include "wpi/MulticastServiceResolver.h"
-#include "wpi/UidVector.h"
-
-namespace wpi {
-struct MulticastHandleManager {
-  wpi::mutex mutex;
-  wpi::UidVector<int, 8> handleIds;
-  wpi::DenseMap<size_t, std::unique_ptr<wpi::MulticastServiceResolver>>
-      resolvers;
-  wpi::DenseMap<size_t, std::unique_ptr<wpi::MulticastServiceAnnouncer>>
-      announcers;
-};
-
-MulticastHandleManager& GetMulticastManager();
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/MulticastServiceAnnouncer.cpp b/wpiutil/src/main/native/cpp/MulticastServiceAnnouncer.cpp
deleted file mode 100644
index 736a03d..0000000
--- a/wpiutil/src/main/native/cpp/MulticastServiceAnnouncer.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceAnnouncer.h"
-
-#include <wpi/SmallVector.h>
-
-#include "MulticastHandleManager.h"
-
-extern "C" {
-WPI_MulticastServiceAnnouncerHandle WPI_CreateMulticastServiceAnnouncer(
-    const char* serviceName, const char* serviceType, int32_t port,
-    int32_t txtCount, const char** keys, const char** values)
-
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-
-  wpi::SmallVector<std::pair<std::string_view, std::string_view>, 8> txts;
-
-  for (int32_t i = 0; i < txtCount; i++) {
-    txts.emplace_back(
-        std::pair<std::string_view, std::string_view>{keys[i], values[i]});
-  }
-
-  auto announcer = std::make_unique<wpi::MulticastServiceAnnouncer>(
-      serviceName, serviceType, port, txts);
-
-  size_t index = manager.handleIds.emplace_back(3);
-  manager.announcers[index] = std::move(announcer);
-
-  return index;
-}
-
-void WPI_FreeMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  manager.announcers[handle] = nullptr;
-  manager.handleIds.erase(handle);
-}
-
-void WPI_StartMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  announcer->Start();
-}
-
-void WPI_StopMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  announcer->Stop();
-}
-
-int32_t WPI_GetMulticastServiceAnnouncerHasImplementation(
-    WPI_MulticastServiceAnnouncerHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  return announcer->HasImplementation();
-}
-}  // extern "C"
diff --git a/wpiutil/src/main/native/cpp/MulticastServiceResolver.cpp b/wpiutil/src/main/native/cpp/MulticastServiceResolver.cpp
deleted file mode 100644
index b834f17..0000000
--- a/wpiutil/src/main/native/cpp/MulticastServiceResolver.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceResolver.h"
-
-#include "MulticastHandleManager.h"
-#include "wpi/MemAlloc.h"
-
-extern "C" {
-WPI_MulticastServiceResolverHandle WPI_CreateMulticastServiceResolver(
-    const char* serviceType)
-
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-
-  auto resolver = std::make_unique<wpi::MulticastServiceResolver>(serviceType);
-
-  size_t index = manager.handleIds.emplace_back(2);
-  manager.resolvers[index] = std::move(resolver);
-
-  return index;
-}
-
-void WPI_FreeMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  manager.resolvers[handle] = nullptr;
-  manager.handleIds.erase(handle);
-}
-
-void WPI_StartMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  resolver->Start();
-}
-
-void WPI_StopMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  resolver->Stop();
-}
-
-int32_t WPI_GetMulticastServiceResolverHasImplementation(
-    WPI_MulticastServiceResolverHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  return resolver->HasImplementation();
-}
-
-WPI_EventHandle WPI_GetMulticastServiceResolverEventHandle(
-    WPI_MulticastServiceResolverHandle handle) {
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  return resolver->GetEventHandle();
-}
-
-WPI_ServiceData* WPI_GetMulticastServiceResolverData(
-    WPI_MulticastServiceResolverHandle handle, int32_t* dataCount) {
-  std::vector<wpi::MulticastServiceResolver::ServiceData> allData;
-  {
-    auto& manager = wpi::GetMulticastManager();
-    std::scoped_lock lock{manager.mutex};
-    auto& resolver = manager.resolvers[handle];
-    allData = resolver->GetData();
-  }
-  if (allData.empty()) {
-    *dataCount = 0;
-    return nullptr;
-  }
-  size_t allocSize = sizeof(WPI_ServiceData) * allData.size();
-
-  for (auto&& data : allData) {
-    // Include space for hostName and serviceType (+ terminators)
-    allocSize += data.hostName.size() + data.serviceName.size() + 2;
-
-    size_t keysTotalLength = 0;
-    size_t valuesTotalLength = 0;
-    // Include space for all keys and values, and pointer array
-    for (auto&& t : data.txt) {
-      allocSize += sizeof(const char*);
-      keysTotalLength += (t.first.size() + 1);
-      allocSize += sizeof(const char*);
-      valuesTotalLength += (t.second.size() + 1);
-    }
-    allocSize += keysTotalLength;
-    allocSize += valuesTotalLength;
-  }
-
-  uint8_t* cDataRaw = reinterpret_cast<uint8_t*>(wpi::safe_malloc(allocSize));
-  if (!cDataRaw) {
-    return nullptr;
-  }
-  WPI_ServiceData* rootArray = reinterpret_cast<WPI_ServiceData*>(cDataRaw);
-  cDataRaw += (sizeof(WPI_ServiceData) + allData.size());
-  WPI_ServiceData* currentData = rootArray;
-
-  for (auto&& data : allData) {
-    currentData->ipv4Address = data.ipv4Address;
-    currentData->port = data.port;
-    currentData->txtCount = data.txt.size();
-
-    std::memcpy(cDataRaw, data.hostName.c_str(), data.hostName.size() + 1);
-    currentData->hostName = reinterpret_cast<const char*>(cDataRaw);
-    cDataRaw += data.hostName.size() + 1;
-
-    std::memcpy(cDataRaw, data.serviceName.c_str(),
-                data.serviceName.size() + 1);
-    currentData->serviceName = reinterpret_cast<const char*>(cDataRaw);
-    cDataRaw += data.serviceName.size() + 1;
-
-    char** valuesPtrArr = reinterpret_cast<char**>(cDataRaw);
-    cDataRaw += (sizeof(char**) * data.txt.size());
-    char** keysPtrArr = reinterpret_cast<char**>(cDataRaw);
-    cDataRaw += (sizeof(char**) * data.txt.size());
-
-    currentData->txtKeys = const_cast<const char**>(keysPtrArr);
-    currentData->txtValues = const_cast<const char**>(valuesPtrArr);
-
-    for (size_t i = 0; i < data.txt.size(); i++) {
-      keysPtrArr[i] = reinterpret_cast<char*>(cDataRaw);
-      std::memcpy(keysPtrArr[i], data.txt[i].first.c_str(),
-                  data.txt[i].first.size() + 1);
-      cDataRaw += (data.txt[i].first.size() + 1);
-
-      valuesPtrArr[i] = reinterpret_cast<char*>(cDataRaw);
-      std::memcpy(valuesPtrArr[i], data.txt[i].second.c_str(),
-                  data.txt[i].second.size() + 1);
-      cDataRaw += (data.txt[i].second.size() + 1);
-    }
-    currentData++;
-  }
-
-  return rootArray;
-}
-
-void WPI_FreeServiceData(WPI_ServiceData* serviceData, int32_t length) {
-  std::free(serviceData);
-}
-}  // extern "C"
diff --git a/wpiutil/src/main/native/cpp/ParallelTcpConnector.cpp b/wpiutil/src/main/native/cpp/ParallelTcpConnector.cpp
deleted file mode 100644
index 5a8394a..0000000
--- a/wpiutil/src/main/native/cpp/ParallelTcpConnector.cpp
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/ParallelTcpConnector.h"
-
-#include <fmt/format.h>
-
-#include "wpi/Logger.h"
-#include "wpi/uv/GetAddrInfo.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Tcp.h"
-#include "wpi/uv/Timer.h"
-#include "wpi/uv/util.h"
-
-using namespace wpi;
-
-ParallelTcpConnector::ParallelTcpConnector(
-    wpi::uv::Loop& loop, wpi::uv::Timer::Time reconnectRate,
-    wpi::Logger& logger, std::function<void(wpi::uv::Tcp& tcp)> connected,
-    const private_init&)
-    : m_loop{loop},
-      m_logger{logger},
-      m_reconnectRate{reconnectRate},
-      m_connected{std::move(connected)},
-      m_reconnectTimer{uv::Timer::Create(loop)} {
-  m_reconnectTimer->timeout.connect([this] {
-    if (!IsConnected()) {
-      WPI_DEBUG1(m_logger, "{}", "timed out, reconnecting");
-      Connect();
-    }
-  });
-}
-
-ParallelTcpConnector::~ParallelTcpConnector() = default;
-
-void ParallelTcpConnector::Close() {
-  CancelAll();
-  m_reconnectTimer->Close();
-}
-
-void ParallelTcpConnector::SetServers(
-    wpi::span<const std::pair<std::string, unsigned int>> servers) {
-  m_servers.assign(servers.begin(), servers.end());
-  if (!IsConnected()) {
-    Connect();
-  }
-}
-
-void ParallelTcpConnector::Disconnected() {
-  if (m_isConnected) {
-    m_isConnected = false;
-    Connect();
-  }
-}
-
-void ParallelTcpConnector::Succeeded(uv::Tcp& tcp) {
-  if (!m_isConnected) {
-    m_isConnected = true;
-    m_reconnectTimer->Stop();
-    CancelAll(&tcp);
-  }
-}
-
-void ParallelTcpConnector::Connect() {
-  if (IsConnected()) {
-    return;
-  }
-
-  CancelAll();
-  m_reconnectTimer->Start(m_reconnectRate);
-
-  WPI_DEBUG3(m_logger, "{}", "starting new connection attempts");
-
-  // kick off parallel lookups
-  for (auto&& server : m_servers) {
-    auto req = std::make_shared<uv::GetAddrInfoReq>();
-    m_resolvers.emplace_back(req);
-
-    req->resolved.connect(
-        [this, req = req.get()](const addrinfo& addrinfo) {
-          if (IsConnected()) {
-            return;
-          }
-
-          // kick off parallel connection attempts
-          for (auto ai = &addrinfo; ai; ai = ai->ai_next) {
-            auto tcp = uv::Tcp::Create(m_loop);
-            m_attempts.emplace_back(tcp);
-
-            auto connreq = std::make_shared<uv::TcpConnectReq>();
-            connreq->connected.connect(
-                [this, tcp = tcp.get()] {
-                  if (m_logger.min_level() <= wpi::WPI_LOG_DEBUG4) {
-                    std::string ip;
-                    unsigned int port = 0;
-                    uv::AddrToName(tcp->GetPeer(), &ip, &port);
-                    WPI_DEBUG4(m_logger,
-                               "successful connection ({}) to {} port {}",
-                               static_cast<void*>(tcp), ip, port);
-                  }
-                  if (IsConnected()) {
-                    tcp->Shutdown([tcp] { tcp->Close(); });
-                    return;
-                  }
-                  if (m_connected) {
-                    m_connected(*tcp);
-                  }
-                },
-                shared_from_this());
-
-            connreq->error = [selfWeak = weak_from_this(),
-                              tcp = tcp.get()](uv::Error err) {
-              if (auto self = selfWeak.lock()) {
-                WPI_DEBUG1(self->m_logger, "connect failure ({}): {}",
-                           static_cast<void*>(tcp), err.str());
-              }
-            };
-
-            if (m_logger.min_level() <= wpi::WPI_LOG_DEBUG4) {
-              std::string ip;
-              unsigned int port = 0;
-              uv::AddrToName(*reinterpret_cast<sockaddr_storage*>(ai->ai_addr),
-                             &ip, &port);
-              WPI_DEBUG4(
-                  m_logger,
-                  "Info({}) starting connection attempt ({}) to {} port {}",
-                  static_cast<void*>(req), static_cast<void*>(tcp.get()), ip,
-                  port);
-            }
-            tcp->Connect(*ai->ai_addr, connreq);
-          }
-        },
-        shared_from_this());
-
-    req->error = [req = req.get(), selfWeak = weak_from_this()](uv::Error err) {
-      if (auto self = selfWeak.lock()) {
-        WPI_DEBUG1(self->m_logger, "GetAddrInfo({}) failure: {}",
-                   static_cast<void*>(req), err.str());
-      }
-    };
-
-    WPI_DEBUG4(m_logger, "starting GetAddrInfo({}) for {} port {}",
-               static_cast<void*>(req.get()), server.first, server.second);
-    addrinfo hints;
-    std::memset(&hints, 0, sizeof(hints));
-    hints.ai_family = AF_UNSPEC;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = IPPROTO_TCP;
-    hints.ai_flags = AI_NUMERICSERV | AI_ADDRCONFIG;
-    uv::GetAddrInfo(m_loop, req, server.first, fmt::format("{}", server.second),
-                    &hints);
-  }
-}
-
-void ParallelTcpConnector::CancelAll(wpi::uv::Tcp* except) {
-  WPI_DEBUG4(m_logger, "{}", "canceling previous attempts");
-  for (auto&& resolverWeak : m_resolvers) {
-    if (auto resolver = resolverWeak.lock()) {
-      WPI_DEBUG4(m_logger, "canceling GetAddrInfo({})",
-                 static_cast<void*>(resolver.get()));
-      resolver->Cancel();
-    }
-  }
-  m_resolvers.clear();
-
-  for (auto&& tcpWeak : m_attempts) {
-    if (auto tcp = tcpWeak.lock()) {
-      if (tcp.get() != except) {
-        WPI_DEBUG4(m_logger, "canceling connection attempt ({})",
-                   static_cast<void*>(tcp.get()));
-        tcp->Close();
-      }
-    }
-  }
-  m_attempts.clear();
-}
diff --git a/wpiutil/src/main/native/cpp/PortForwarder.cpp b/wpiutil/src/main/native/cpp/PortForwarder.cpp
deleted file mode 100644
index a423d48..0000000
--- a/wpiutil/src/main/native/cpp/PortForwarder.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/PortForwarder.h"
-
-#include "fmt/format.h"
-#include "wpi/DenseMap.h"
-#include "wpi/EventLoopRunner.h"
-#include "wpi/uv/GetAddrInfo.h"
-#include "wpi/uv/Tcp.h"
-#include "wpi/uv/Timer.h"
-
-using namespace wpi;
-
-struct PortForwarder::Impl {
- public:
-  EventLoopRunner runner;
-  DenseMap<unsigned int, std::weak_ptr<uv::Tcp>> servers;
-};
-
-PortForwarder::PortForwarder() : m_impl{new Impl} {}
-
-PortForwarder& PortForwarder::GetInstance() {
-  static PortForwarder instance;
-  return instance;
-}
-
-static void CopyStream(uv::Stream& in, std::weak_ptr<uv::Stream> outWeak) {
-  in.data.connect([&in, outWeak](uv::Buffer& buf, size_t len) {
-    uv::Buffer buf2 = buf.Dup();
-    buf2.len = len;
-    auto out = outWeak.lock();
-    if (!out) {
-      buf2.Deallocate();
-      in.Close();
-      return;
-    }
-    out->Write({buf2}, [](auto bufs, uv::Error) {
-      for (auto buf : bufs) {
-        buf.Deallocate();
-      }
-    });
-  });
-}
-
-void PortForwarder::Add(unsigned int port, std::string_view remoteHost,
-                        unsigned int remotePort) {
-  m_impl->runner.ExecSync([&](uv::Loop& loop) {
-    auto server = uv::Tcp::Create(loop);
-
-    // bind to local port
-    server->Bind("", port);
-
-    // when we get a connection, accept it
-    server->connection.connect([serverPtr = server.get(),
-                                host = std::string{remoteHost}, remotePort] {
-      auto& loop = serverPtr->GetLoopRef();
-      auto client = serverPtr->Accept();
-      if (!client) {
-        return;
-      }
-
-      // close on error
-      client->error.connect(
-          [clientPtr = client.get()](uv::Error err) { clientPtr->Close(); });
-
-      // connected flag
-      auto connected = std::make_shared<bool>(false);
-      client->SetData(connected);
-
-      auto remote = uv::Tcp::Create(loop);
-      remote->error.connect(
-          [remotePtr = remote.get(),
-           clientWeak = std::weak_ptr<uv::Tcp>(client)](uv::Error err) {
-            remotePtr->Close();
-            if (auto client = clientWeak.lock()) {
-              client->Close();
-            }
-          });
-
-      // resolve address
-      uv::GetAddrInfo(
-          loop,
-          [clientWeak = std::weak_ptr<uv::Tcp>(client),
-           remoteWeak = std::weak_ptr<uv::Tcp>(remote)](const addrinfo& addr) {
-            auto remote = remoteWeak.lock();
-            if (!remote) {
-              return;
-            }
-
-            // connect to remote address/port
-            remote->Connect(*addr.ai_addr, [remotePtr = remote.get(),
-                                            remoteWeak, clientWeak] {
-              auto client = clientWeak.lock();
-              if (!client) {
-                remotePtr->Close();
-                return;
-              }
-              *(client->GetData<bool>()) = true;
-
-              // close both when either side closes
-              client->end.connect([clientPtr = client.get(), remoteWeak] {
-                clientPtr->Close();
-                if (auto remote = remoteWeak.lock()) {
-                  remote->Close();
-                }
-              });
-              remotePtr->end.connect([remotePtr, clientWeak] {
-                remotePtr->Close();
-                if (auto client = clientWeak.lock()) {
-                  client->Close();
-                }
-              });
-
-              // copy bidirectionally
-              client->StartRead();
-              remotePtr->StartRead();
-              CopyStream(*client, remoteWeak);
-              CopyStream(*remotePtr, clientWeak);
-            });
-          },
-          host, fmt::to_string(remotePort));
-
-      // time out for connection
-      uv::Timer::SingleShot(loop, uv::Timer::Time{500},
-                            [connectedWeak = std::weak_ptr<bool>(connected),
-                             clientWeak = std::weak_ptr<uv::Tcp>(client),
-                             remoteWeak = std::weak_ptr<uv::Tcp>(remote)] {
-                              if (auto connected = connectedWeak.lock()) {
-                                if (!*connected) {
-                                  if (auto client = clientWeak.lock()) {
-                                    client->Close();
-                                  }
-                                  if (auto remote = remoteWeak.lock()) {
-                                    remote->Close();
-                                  }
-                                }
-                              }
-                            });
-    });
-
-    // start listening for incoming connections
-    server->Listen();
-
-    m_impl->servers[port] = server;
-  });
-}
-
-void PortForwarder::Remove(unsigned int port) {
-  m_impl->runner.ExecSync([&](uv::Loop& loop) {
-    if (auto server = m_impl->servers.lookup(port).lock()) {
-      server->Close();
-      m_impl->servers.erase(port);
-    }
-  });
-}
diff --git a/wpiutil/src/main/native/cpp/SafeThread.cpp b/wpiutil/src/main/native/cpp/SafeThread.cpp
index bbecc5c..ba1eba3 100644
--- a/wpiutil/src/main/native/cpp/SafeThread.cpp
+++ b/wpiutil/src/main/native/cpp/SafeThread.cpp
@@ -4,10 +4,50 @@
 
 #include "wpi/SafeThread.h"
 
+#include <atomic>
+
 using namespace wpi;
 
+// thread start/stop notifications for bindings that need to set up
+// per-thread state
+
+static void* DefaultOnThreadStart() {
+  return nullptr;
+}
+static void DefaultOnThreadEnd(void*) {}
+
+using OnThreadStartFn = void* (*)();
+using OnThreadEndFn = void (*)(void*);
+static std::atomic<int> gSafeThreadRefcount;
+static std::atomic<OnThreadStartFn> gOnSafeThreadStart{DefaultOnThreadStart};
+static std::atomic<OnThreadEndFn> gOnSafeThreadEnd{DefaultOnThreadEnd};
+
+namespace wpi::impl {
+void SetSafeThreadNotifiers(OnThreadStartFn OnStart, OnThreadEndFn OnEnd) {
+  if (gSafeThreadRefcount != 0) {
+    throw std::runtime_error(
+        "cannot set notifier while safe threads are running");
+  }
+  // Note: there's a race here, but if you're not calling this function on
+  // the main thread before you start anything else, you're using this function
+  // incorrectly
+  gOnSafeThreadStart = OnStart ? OnStart : DefaultOnThreadStart;
+  gOnSafeThreadEnd = OnEnd ? OnEnd : DefaultOnThreadEnd;
+}
+}  // namespace wpi::impl
+
+void SafeThread::Stop() {
+  m_active = false;
+  m_cond.notify_all();
+}
+
+void SafeThreadEvent::Stop() {
+  m_active = false;
+  m_stopEvent.Set();
+}
+
 detail::SafeThreadProxyBase::SafeThreadProxyBase(
-    std::shared_ptr<SafeThread> thr)
+    std::shared_ptr<SafeThreadBase> thr)
     : m_thread(std::move(thr)) {
   if (!m_thread) {
     return;
@@ -28,12 +68,18 @@
   }
 }
 
-void detail::SafeThreadOwnerBase::Start(std::shared_ptr<SafeThread> thr) {
+void detail::SafeThreadOwnerBase::Start(std::shared_ptr<SafeThreadBase> thr) {
   std::scoped_lock lock(m_mutex);
   if (auto thr = m_thread.lock()) {
     return;
   }
-  m_stdThread = std::thread([=] { thr->Main(); });
+  m_stdThread = std::thread([=] {
+    gSafeThreadRefcount++;
+    void* opaque = (gOnSafeThreadStart.load())();
+    thr->Main();
+    (gOnSafeThreadEnd.load())(opaque);
+    gSafeThreadRefcount--;
+  });
   thr->m_threadId = m_stdThread.get_id();
   m_thread = thr;
 }
@@ -41,8 +87,7 @@
 void detail::SafeThreadOwnerBase::Stop() {
   std::scoped_lock lock(m_mutex);
   if (auto thr = m_thread.lock()) {
-    thr->m_active = false;
-    thr->m_cond.notify_all();
+    thr->Stop();
     m_thread.reset();
   }
   if (m_stdThread.joinable()) {
@@ -56,8 +101,7 @@
     auto stdThread = std::move(m_stdThread);
     m_thread.reset();
     lock.unlock();
-    thr->m_active = false;
-    thr->m_cond.notify_all();
+    thr->Stop();
     stdThread.join();
   } else if (m_stdThread.joinable()) {
     m_stdThread.detach();
@@ -85,8 +129,8 @@
   return m_stdThread.native_handle();
 }
 
-std::shared_ptr<SafeThread> detail::SafeThreadOwnerBase::GetThreadSharedPtr()
-    const {
+std::shared_ptr<SafeThreadBase>
+detail::SafeThreadOwnerBase::GetThreadSharedPtr() const {
   std::scoped_lock lock(m_mutex);
   return m_thread.lock();
 }
diff --git a/wpiutil/src/main/native/cpp/SocketError.cpp b/wpiutil/src/main/native/cpp/SocketError.cpp
deleted file mode 100644
index 3f08d1e..0000000
--- a/wpiutil/src/main/native/cpp/SocketError.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/SocketError.h"
-
-#ifdef _WIN32
-#include <winsock2.h>
-#else
-#include <cerrno>
-#include <cstring>
-#endif
-
-namespace wpi {
-
-int SocketErrno() {
-#ifdef _WIN32
-  return WSAGetLastError();
-#else
-  return errno;
-#endif
-}
-
-std::string SocketStrerror(int code) {
-#ifdef _WIN32
-  LPSTR errstr = nullptr;
-  FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0,
-                code, 0, (LPSTR)&errstr, 0, 0);
-  std::string rv(errstr);
-  LocalFree(errstr);
-  return rv;
-#else
-  return std::strerror(code);
-#endif
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/Synchronization.cpp b/wpiutil/src/main/native/cpp/Synchronization.cpp
index da97897..f9ac75b 100644
--- a/wpiutil/src/main/native/cpp/Synchronization.cpp
+++ b/wpiutil/src/main/native/cpp/Synchronization.cpp
@@ -5,6 +5,7 @@
 #include "wpi/Synchronization.h"
 
 #include <algorithm>
+#include <atomic>
 #include <cstring>
 #include <mutex>
 
@@ -16,6 +17,8 @@
 
 using namespace wpi;
 
+static std::atomic_bool gShutdown{false};
+
 namespace {
 
 struct State {
@@ -25,6 +28,8 @@
 };
 
 struct HandleManager {
+  ~HandleManager() { gShutdown = true; }
+
   wpi::mutex mutex;
   wpi::UidVector<int, 8> eventIds;
   wpi::UidVector<int, 8> semaphoreIds;
@@ -40,6 +45,9 @@
 
 WPI_EventHandle wpi::CreateEvent(bool manualReset, bool initialState) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return {};
+  }
   std::scoped_lock lock{manager.mutex};
 
   auto index = manager.eventIds.emplace_back(0);
@@ -61,6 +69,9 @@
   DestroySignalObject(handle);
 
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
   manager.eventIds.erase(handle & 0xffffff);
 }
@@ -83,6 +94,9 @@
 
 WPI_SemaphoreHandle wpi::CreateSemaphore(int initialCount, int maximumCount) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return {};
+  }
   std::scoped_lock lock{manager.mutex};
 
   auto index = manager.semaphoreIds.emplace_back(maximumCount);
@@ -104,6 +118,9 @@
   DestroySignalObject(handle);
 
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
   manager.eventIds.erase(handle & 0xffffff);
 }
@@ -119,6 +136,9 @@
   int index = handle & 0xffffff;
 
   auto& manager = GetManager();
+  if (gShutdown) {
+    return true;
+  }
   std::scoped_lock lock{manager.mutex};
   auto it = manager.states.find(handle);
   if (it == manager.states.end()) {
@@ -146,22 +166,26 @@
 bool wpi::WaitForObject(WPI_Handle handle, double timeout, bool* timedOut) {
   WPI_Handle signaledValue;
   auto signaled = WaitForObjects(
-      wpi::span(&handle, 1), wpi::span(&signaledValue, 1), timeout, timedOut);
+      std::span(&handle, 1), std::span(&signaledValue, 1), timeout, timedOut);
   if (signaled.empty()) {
     return false;
   }
   return (signaled[0] & 0x80000000ul) == 0;
 }
 
-wpi::span<WPI_Handle> wpi::WaitForObjects(wpi::span<const WPI_Handle> handles,
-                                          wpi::span<WPI_Handle> signaled) {
+std::span<WPI_Handle> wpi::WaitForObjects(std::span<const WPI_Handle> handles,
+                                          std::span<WPI_Handle> signaled) {
   return WaitForObjects(handles, signaled, -1, nullptr);
 }
 
-wpi::span<WPI_Handle> wpi::WaitForObjects(wpi::span<const WPI_Handle> handles,
-                                          wpi::span<WPI_Handle> signaled,
+std::span<WPI_Handle> wpi::WaitForObjects(std::span<const WPI_Handle> handles,
+                                          std::span<WPI_Handle> signaled,
                                           double timeout, bool* timedOut) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    *timedOut = false;
+    return {};
+  }
   std::unique_lock lock{manager.mutex};
   wpi::condition_variable cv;
   bool addedWaiters = false;
@@ -240,6 +264,9 @@
 void wpi::CreateSignalObject(WPI_Handle handle, bool manualReset,
                              bool initialState) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
   auto& state = manager.states[handle];
   state.signaled = initialState ? 1 : 0;
@@ -248,6 +275,9 @@
 
 void wpi::SetSignalObject(WPI_Handle handle) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
   auto it = manager.states.find(handle);
   if (it == manager.states.end()) {
@@ -266,6 +296,9 @@
 
 void wpi::ResetSignalObject(WPI_Handle handle) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
   auto it = manager.states.find(handle);
   if (it != manager.states.end()) {
@@ -275,6 +308,9 @@
 
 void wpi::DestroySignalObject(WPI_Handle handle) {
   auto& manager = GetManager();
+  if (gShutdown) {
+    return;
+  }
   std::scoped_lock lock{manager.mutex};
 
   auto it = manager.states.find(handle);
@@ -332,8 +368,8 @@
 
 int WPI_WaitForObjects(const WPI_Handle* handles, int handles_count,
                        WPI_Handle* signaled) {
-  return wpi::WaitForObjects(wpi::span(handles, handles_count),
-                             wpi::span(signaled, handles_count))
+  return wpi::WaitForObjects(std::span(handles, handles_count),
+                             std::span(signaled, handles_count))
       .size();
 }
 
@@ -341,8 +377,8 @@
                               WPI_Handle* signaled, double timeout,
                               int* timed_out) {
   bool timedOutBool;
-  auto signaledResult = wpi::WaitForObjects(wpi::span(handles, handles_count),
-                                            wpi::span(signaled, handles_count),
+  auto signaledResult = wpi::WaitForObjects(std::span(handles, handles_count),
+                                            std::span(signaled, handles_count),
                                             timeout, &timedOutBool);
   *timed_out = timedOutBool ? 1 : 0;
   return signaledResult.size();
diff --git a/wpiutil/src/main/native/cpp/TCPAcceptor.cpp b/wpiutil/src/main/native/cpp/TCPAcceptor.cpp
deleted file mode 100644
index 8d12ac3..0000000
--- a/wpiutil/src/main/native/cpp/TCPAcceptor.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-   TCPAcceptor.cpp
-
-   TCPAcceptor class definition. TCPAcceptor provides methods to passively
-   establish TCP/IP connections with clients.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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.
-*/
-
-#include "wpi/TCPAcceptor.h"
-
-#include <cstdio>
-#include <cstring>
-
-#ifdef _WIN32
-#define _WINSOCK_DEPRECATED_NO_WARNINGS
-#include <WinSock2.h>
-#include <Ws2tcpip.h>
-#pragma comment(lib, "Ws2_32.lib")
-#else
-#include <arpa/inet.h>
-#include <fcntl.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#endif
-
-#include "wpi/Logger.h"
-#include "wpi/SmallString.h"
-#include "wpi/SocketError.h"
-
-using namespace wpi;
-
-TCPAcceptor::TCPAcceptor(int port, std::string_view address, Logger& logger)
-    : m_lsd(0),
-      m_port(port),
-      m_address(address),
-      m_listening(false),
-      m_logger(logger) {
-  m_shutdown = false;
-#ifdef _WIN32
-  WSAData wsaData;
-  WORD wVersionRequested = MAKEWORD(2, 2);
-  (void)WSAStartup(wVersionRequested, &wsaData);
-#endif
-}
-
-TCPAcceptor::~TCPAcceptor() {
-  if (m_lsd > 0) {
-    shutdown();
-#ifdef _WIN32
-    closesocket(m_lsd);
-#else
-    close(m_lsd);
-#endif
-  }
-#ifdef _WIN32
-  WSACleanup();
-#endif
-}
-
-int TCPAcceptor::start() {
-  if (m_listening) {
-    return 0;
-  }
-
-  m_lsd = socket(PF_INET, SOCK_STREAM, 0);
-  if (m_lsd < 0) {
-    WPI_ERROR(m_logger, "{}", "could not create socket");
-    return -1;
-  }
-  struct sockaddr_in address;
-
-  std::memset(&address, 0, sizeof(address));
-  address.sin_family = PF_INET;
-  if (m_address.size() > 0) {
-#ifdef _WIN32
-    SmallString<128> addr_copy(m_address);
-    addr_copy.push_back('\0');
-    int res = InetPton(PF_INET, addr_copy.data(), &(address.sin_addr));
-#else
-    int res = inet_pton(PF_INET, m_address.c_str(), &(address.sin_addr));
-#endif
-    if (res != 1) {
-      WPI_ERROR(m_logger, "could not resolve {} address", m_address);
-      return -1;
-    }
-  } else {
-    address.sin_addr.s_addr = INADDR_ANY;
-  }
-  address.sin_port = htons(m_port);
-
-#ifdef _WIN32
-  int optval = 1;
-  setsockopt(m_lsd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-             reinterpret_cast<char*>(&optval), sizeof optval);
-#else
-  int optval = 1;
-  setsockopt(m_lsd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&optval),
-             sizeof optval);
-#endif
-
-  int result = bind(m_lsd, reinterpret_cast<struct sockaddr*>(&address),
-                    sizeof(address));
-  if (result != 0) {
-    WPI_ERROR(m_logger, "bind() to port {} failed: {}", m_port,
-              SocketStrerror());
-    return result;
-  }
-
-  result = listen(m_lsd, 5);
-  if (result != 0) {
-    WPI_ERROR(m_logger, "listen() on port {} failed: {}", m_port,
-              SocketStrerror());
-    return result;
-  }
-  m_listening = true;
-  return result;
-}
-
-void TCPAcceptor::shutdown() {
-  m_shutdown = true;
-#ifdef _WIN32
-  ::shutdown(m_lsd, SD_BOTH);
-
-  // this is ugly, but the easiest way to do this
-  // force wakeup of accept() with a non-blocking connect to ourselves
-  struct sockaddr_in address;
-
-  std::memset(&address, 0, sizeof(address));
-  address.sin_family = PF_INET;
-  SmallString<128> addr_copy;
-  if (m_address.size() > 0)
-    addr_copy = m_address;
-  else
-    addr_copy = "127.0.0.1";
-  addr_copy.push_back('\0');
-  int size = sizeof(address);
-  if (WSAStringToAddress(addr_copy.data(), PF_INET, nullptr,
-                         (struct sockaddr*)&address, &size) != 0)
-    return;
-  address.sin_port = htons(m_port);
-
-  int result = -1, sd = socket(AF_INET, SOCK_STREAM, 0);
-  if (sd < 0)
-    return;
-
-  // Set socket to non-blocking
-  u_long mode = 1;
-  ioctlsocket(sd, FIONBIO, &mode);
-
-  // Try to connect
-  ::connect(sd, (struct sockaddr*)&address, sizeof(address));
-
-  // Close
-  ::closesocket(sd);
-
-#else
-  ::shutdown(m_lsd, SHUT_RDWR);
-  int nullfd = ::open("/dev/null", O_RDONLY);
-  if (nullfd >= 0) {
-    ::dup2(nullfd, m_lsd);
-    ::close(nullfd);
-  }
-#endif
-}
-
-std::unique_ptr<NetworkStream> TCPAcceptor::accept() {
-  if (!m_listening || m_shutdown) {
-    return nullptr;
-  }
-
-  struct sockaddr_in address;
-#ifdef _WIN32
-  int len = sizeof(address);
-#else
-  socklen_t len = sizeof(address);
-#endif
-  std::memset(&address, 0, sizeof(address));
-  int sd = ::accept(m_lsd, reinterpret_cast<struct sockaddr*>(&address), &len);
-  if (sd < 0) {
-    if (!m_shutdown) {
-      WPI_ERROR(m_logger, "accept() on port {} failed: {}", m_port,
-                SocketStrerror());
-    }
-    return nullptr;
-  }
-  if (m_shutdown) {
-#ifdef _WIN32
-    closesocket(sd);
-#else
-    close(sd);
-#endif
-    return nullptr;
-  }
-  return std::unique_ptr<NetworkStream>(new TCPStream(sd, &address));
-}
diff --git a/wpiutil/src/main/native/cpp/TCPConnector.cpp b/wpiutil/src/main/native/cpp/TCPConnector.cpp
deleted file mode 100644
index ed97962..0000000
--- a/wpiutil/src/main/native/cpp/TCPConnector.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
-   TCPConnector.h
-
-   TCPConnector class definition. TCPConnector provides methods to actively
-   establish TCP/IP connections with a server.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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
-*/
-
-#include "wpi/TCPConnector.h"
-
-#include <fcntl.h>
-
-#include <cerrno>
-#include <cstdio>
-#include <cstring>
-
-#ifdef _WIN32
-#include <WS2tcpip.h>
-#include <WinSock2.h>
-#else
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/select.h>
-#include <unistd.h>
-#endif
-
-#include "wpi/Logger.h"
-#include "wpi/SmallString.h"
-#include "wpi/SocketError.h"
-#include "wpi/TCPStream.h"
-
-using namespace wpi;
-
-static int ResolveHostName(const char* hostname, struct in_addr* addr) {
-  struct addrinfo hints;
-  struct addrinfo* res;
-
-  hints.ai_flags = 0;
-  hints.ai_family = AF_INET;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = 0;
-  hints.ai_addrlen = 0;
-  hints.ai_addr = nullptr;
-  hints.ai_canonname = nullptr;
-  hints.ai_next = nullptr;
-  int result = getaddrinfo(hostname, nullptr, &hints, &res);
-  if (result == 0) {
-    std::memcpy(
-        addr, &(reinterpret_cast<struct sockaddr_in*>(res->ai_addr)->sin_addr),
-        sizeof(struct in_addr));
-    freeaddrinfo(res);
-  }
-  return result;
-}
-
-std::unique_ptr<NetworkStream> TCPConnector::connect(const char* server,
-                                                     int port, Logger& logger,
-                                                     int timeout) {
-#ifdef _WIN32
-  struct WSAHelper {
-    WSAHelper() {
-      WSAData wsaData;
-      WORD wVersionRequested = MAKEWORD(2, 2);
-      WSAStartup(wVersionRequested, &wsaData);
-    }
-    ~WSAHelper() { WSACleanup(); }
-  };
-  static WSAHelper helper;
-#endif
-  struct sockaddr_in address;
-
-  std::memset(&address, 0, sizeof(address));
-  address.sin_family = AF_INET;
-  if (ResolveHostName(server, &(address.sin_addr)) != 0) {
-#ifdef _WIN32
-    SmallString<128> addr_copy(server);
-    addr_copy.push_back('\0');
-    int res = InetPton(PF_INET, addr_copy.data(), &(address.sin_addr));
-#else
-    int res = inet_pton(PF_INET, server, &(address.sin_addr));
-#endif
-    if (res != 1) {
-      WPI_ERROR(logger, "could not resolve {} address", server);
-      return nullptr;
-    }
-  }
-  address.sin_port = htons(port);
-
-  if (timeout == 0) {
-    int sd = socket(AF_INET, SOCK_STREAM, 0);
-    if (sd < 0) {
-      WPI_ERROR(logger, "{}", "could not create socket");
-      return nullptr;
-    }
-    if (::connect(sd, reinterpret_cast<struct sockaddr*>(&address),
-                  sizeof(address)) != 0) {
-      WPI_ERROR(logger, "connect() to {} port {} failed: {}", server, port,
-                SocketStrerror());
-#ifdef _WIN32
-      closesocket(sd);
-#else
-      ::close(sd);
-#endif
-      return nullptr;
-    }
-    return std::unique_ptr<NetworkStream>(new TCPStream(sd, &address));
-  }
-
-  fd_set sdset;
-  struct timeval tv;
-  socklen_t len;
-  int result = -1, valopt, sd = socket(AF_INET, SOCK_STREAM, 0);
-  if (sd < 0) {
-    WPI_ERROR(logger, "{}", "could not create socket");
-    return nullptr;
-  }
-
-// Set socket to non-blocking
-#ifdef _WIN32
-  u_long mode = 1;
-  if (ioctlsocket(sd, FIONBIO, &mode) == SOCKET_ERROR)
-    WPI_WARNING(logger, "could not set socket to non-blocking: {}",
-                SocketStrerror());
-#else
-  int arg;
-  arg = fcntl(sd, F_GETFL, nullptr);
-  if (arg < 0) {
-    WPI_WARNING(logger, "could not set socket to non-blocking: {}",
-                SocketStrerror());
-  } else {
-    arg |= O_NONBLOCK;
-    if (fcntl(sd, F_SETFL, arg) < 0) {
-      WPI_WARNING(logger, "could not set socket to non-blocking: {}",
-                  SocketStrerror());
-    }
-  }
-#endif
-
-  // Connect with time limit
-  if ((result = ::connect(sd, reinterpret_cast<struct sockaddr*>(&address),
-                          sizeof(address))) < 0) {
-    int my_errno = SocketErrno();
-#ifdef _WIN32
-    if (my_errno == WSAEWOULDBLOCK || my_errno == WSAEINPROGRESS) {
-#else
-    if (my_errno == EWOULDBLOCK || my_errno == EINPROGRESS) {
-#endif
-      tv.tv_sec = timeout;
-      tv.tv_usec = 0;
-      FD_ZERO(&sdset);
-      FD_SET(sd, &sdset);
-      if (select(sd + 1, nullptr, &sdset, nullptr, &tv) > 0) {
-        len = sizeof(int);
-        getsockopt(sd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&valopt),
-                   &len);
-        if (valopt) {
-          WPI_ERROR(logger, "select() to {} port {} error {} - {}", server,
-                    port, valopt, SocketStrerror(valopt));
-        } else {
-          // connection established
-          result = 0;
-        }
-      } else {
-        WPI_INFO(logger, "connect() to {} port {} timed out", server, port);
-      }
-    } else {
-      WPI_ERROR(logger, "connect() to {} port {} error {} - {}", server, port,
-                SocketErrno(), SocketStrerror());
-    }
-  }
-
-// Return socket to blocking mode
-#ifdef _WIN32
-  mode = 0;
-  if (ioctlsocket(sd, FIONBIO, &mode) == SOCKET_ERROR)
-    WPI_WARNING(logger, "could not set socket to blocking: {}",
-                SocketStrerror());
-#else
-  arg = fcntl(sd, F_GETFL, nullptr);
-  if (arg < 0) {
-    WPI_WARNING(logger, "could not set socket to blocking: {}",
-                SocketStrerror());
-  } else {
-    arg &= (~O_NONBLOCK);
-    if (fcntl(sd, F_SETFL, arg) < 0) {
-      WPI_WARNING(logger, "could not set socket to blocking: {}",
-                  SocketStrerror());
-    }
-  }
-#endif
-
-  // Create stream object if connected, close if not.
-  if (result == -1) {
-#ifdef _WIN32
-    closesocket(sd);
-#else
-    ::close(sd);
-#endif
-    return nullptr;
-  }
-  return std::unique_ptr<NetworkStream>(new TCPStream(sd, &address));
-}
diff --git a/wpiutil/src/main/native/cpp/TCPConnector_parallel.cpp b/wpiutil/src/main/native/cpp/TCPConnector_parallel.cpp
deleted file mode 100644
index 26258cf..0000000
--- a/wpiutil/src/main/native/cpp/TCPConnector_parallel.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/TCPConnector.h"  // NOLINT(build/include_order)
-
-#include <atomic>
-#include <chrono>
-#include <thread>
-#include <tuple>
-
-#include "wpi/SmallSet.h"
-#include "wpi/condition_variable.h"
-#include "wpi/mutex.h"
-
-using namespace wpi;
-
-// MSVC < 1900 doesn't have support for thread_local
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-// clang check for availability of thread_local
-#if !defined(__has_feature) || __has_feature(cxx_thread_local)
-#define HAVE_THREAD_LOCAL
-#endif
-#endif
-
-std::unique_ptr<NetworkStream> TCPConnector::connect_parallel(
-    span<const std::pair<const char*, int>> servers, Logger& logger,
-    int timeout) {
-  if (servers.empty()) {
-    return nullptr;
-  }
-
-  // structure to make sure we don't start duplicate workers
-  struct GlobalState {
-    wpi::mutex mtx;
-#ifdef HAVE_THREAD_LOCAL
-    SmallSet<std::pair<std::string, int>, 16> active;
-#else
-    SmallSet<std::tuple<std::thread::id, std::string, int>, 16> active;
-#endif
-  };
-#ifdef HAVE_THREAD_LOCAL
-  thread_local auto global = std::make_shared<GlobalState>();
-#else
-  static auto global = std::make_shared<GlobalState>();
-  auto this_id = std::this_thread::get_id();
-#endif
-  auto local = global;  // copy to an automatic variable for lambda capture
-
-  // structure shared between threads and this function
-  struct Result {
-    wpi::mutex mtx;
-    wpi::condition_variable cv;
-    std::unique_ptr<NetworkStream> stream;
-    std::atomic<unsigned int> count{0};
-    std::atomic<bool> done{false};
-  };
-  auto result = std::make_shared<Result>();
-
-  // start worker threads; this is I/O bound so we don't limit to # of procs
-  Logger* plogger = &logger;
-  unsigned int num_workers = 0;
-  for (const auto& server : servers) {
-    std::pair<std::string, int> server_copy{std::string{server.first},
-                                            server.second};
-#ifdef HAVE_THREAD_LOCAL
-    const auto& active_tracker = server_copy;
-#else
-    std::tuple<std::thread::id, std::string, int> active_tracker{
-        this_id, server_copy.first, server_copy.second};
-#endif
-
-    // don't start a new worker if we had a previously still-active connection
-    // attempt to the same server
-    {
-      std::scoped_lock lock(local->mtx);
-      if (local->active.count(active_tracker) > 0) {
-        continue;  // already in set
-      }
-    }
-
-    ++num_workers;
-
-    // start the worker
-    std::thread([=] {
-      if (!result->done) {
-        // add to global state
-        {
-          std::scoped_lock lock(local->mtx);
-          local->active.insert(active_tracker);
-        }
-
-        // try to connect
-        auto stream = connect(server_copy.first.c_str(), server_copy.second,
-                              *plogger, timeout);
-
-        // remove from global state
-        {
-          std::scoped_lock lock(local->mtx);
-          local->active.erase(active_tracker);
-        }
-
-        // successful connection
-        if (stream) {
-          std::scoped_lock lock(result->mtx);
-          if (!result->done.exchange(true)) {
-            result->stream = std::move(stream);
-          }
-        }
-      }
-      ++result->count;
-      result->cv.notify_all();
-    }).detach();
-  }
-
-  // wait for a result, timeout, or all finished
-  std::unique_lock lock(result->mtx);
-  if (timeout == 0) {
-    result->cv.wait(
-        lock, [&] { return result->stream || result->count >= num_workers; });
-  } else {
-    auto timeout_time =
-        std::chrono::steady_clock::now() + std::chrono::seconds(timeout);
-    result->cv.wait_until(lock, timeout_time, [&] {
-      return result->stream || result->count >= num_workers;
-    });
-  }
-
-  // no need to wait for remaining worker threads; shared_ptr will clean up
-  return std::move(result->stream);
-}
diff --git a/wpiutil/src/main/native/cpp/TCPStream.cpp b/wpiutil/src/main/native/cpp/TCPStream.cpp
deleted file mode 100644
index 4567161..0000000
--- a/wpiutil/src/main/native/cpp/TCPStream.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-   TCPStream.h
-
-   TCPStream class definition. TCPStream provides methods to transfer
-   data between peers over a TCP/IP connection.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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.
-*/
-
-#include "wpi/TCPStream.h"
-
-#include <fcntl.h>
-
-#ifdef _WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <arpa/inet.h>
-#include <netinet/tcp.h>
-#include <unistd.h>
-#endif
-
-#include <cerrno>
-
-using namespace wpi;
-
-TCPStream::TCPStream(int sd, sockaddr_in* address)
-    : m_sd(sd), m_blocking(true) {
-  char ip[50];
-#ifdef _WIN32
-  InetNtop(PF_INET, &(address->sin_addr.s_addr), ip, sizeof(ip) - 1);
-#else
-  inet_ntop(PF_INET, reinterpret_cast<in_addr*>(&(address->sin_addr.s_addr)),
-            ip, sizeof(ip) - 1);
-#ifdef SO_NOSIGPIPE
-  // disable SIGPIPE on Mac OS X
-  int set = 1;
-  setsockopt(m_sd, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast<char*>(&set),
-             sizeof set);
-#endif
-#endif
-  m_peerIP = ip;
-  m_peerPort = ntohs(address->sin_port);
-}
-
-TCPStream::~TCPStream() {
-  close();
-}
-
-size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
-  if (m_sd < 0) {
-    *err = kConnectionClosed;
-    return 0;
-  }
-#ifdef _WIN32
-  WSABUF wsaBuf;
-  wsaBuf.buf = const_cast<char*>(buffer);
-  wsaBuf.len = (ULONG)len;
-  DWORD rv;
-  bool result = true;
-  while (WSASend(m_sd, &wsaBuf, 1, &rv, 0, nullptr, nullptr) == SOCKET_ERROR) {
-    if (WSAGetLastError() != WSAEWOULDBLOCK) {
-      result = false;
-      break;
-    }
-    if (!m_blocking) {
-      *err = kWouldBlock;
-      return 0;
-    }
-    Sleep(1);
-  }
-  if (!result) {
-    char Buffer[128];
-#ifdef _MSC_VER
-    sprintf_s(Buffer, "Send() failed: WSA error=%d\n", WSAGetLastError());
-#else
-    std::snprintf(Buffer, sizeof(Buffer), "Send() failed: WSA error=%d\n",
-                  WSAGetLastError());
-#endif
-    OutputDebugStringA(Buffer);
-    *err = kConnectionReset;
-    return 0;
-  }
-#else
-#ifdef MSG_NOSIGNAL
-  // disable SIGPIPE on Linux
-  ssize_t rv = ::send(m_sd, buffer, len, MSG_NOSIGNAL);
-#else
-  ssize_t rv = ::send(m_sd, buffer, len, 0);
-#endif
-  if (rv < 0) {
-    if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-      *err = kWouldBlock;
-    } else {
-      *err = kConnectionReset;
-    }
-    return 0;
-  }
-#endif
-  return static_cast<size_t>(rv);
-}
-
-size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
-  if (m_sd < 0) {
-    *err = kConnectionClosed;
-    return 0;
-  }
-#ifdef _WIN32
-  int rv;
-#else
-  ssize_t rv;
-#endif
-  if (timeout <= 0) {
-#ifdef _WIN32
-    rv = recv(m_sd, buffer, len, 0);
-#else
-    rv = read(m_sd, buffer, len);
-#endif
-  } else if (WaitForReadEvent(timeout)) {
-#ifdef _WIN32
-    rv = recv(m_sd, buffer, len, 0);
-#else
-    rv = read(m_sd, buffer, len);
-#endif
-  } else {
-    *err = kConnectionTimedOut;
-    return 0;
-  }
-  if (rv < 0) {
-#ifdef _WIN32
-    if (!m_blocking && WSAGetLastError() == WSAEWOULDBLOCK) {
-#else
-    if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-#endif
-      *err = kWouldBlock;
-    } else {
-      *err = kConnectionReset;
-    }
-    return 0;
-  }
-  return static_cast<size_t>(rv);
-}
-
-void TCPStream::close() {
-  if (m_sd >= 0) {
-#ifdef _WIN32
-    ::shutdown(m_sd, SD_BOTH);
-    closesocket(m_sd);
-#else
-    ::shutdown(m_sd, SHUT_RDWR);
-    ::close(m_sd);
-#endif
-  }
-  m_sd = -1;
-}
-
-std::string_view TCPStream::getPeerIP() const {
-  return m_peerIP;
-}
-
-int TCPStream::getPeerPort() const {
-  return m_peerPort;
-}
-
-void TCPStream::setNoDelay() {
-  if (m_sd < 0) {
-    return;
-  }
-  int optval = 1;
-  setsockopt(m_sd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&optval),
-             sizeof optval);
-}
-
-bool TCPStream::setBlocking(bool enabled) {
-  if (m_sd < 0) {
-    return true;  // silently accept
-  }
-#ifdef _WIN32
-  u_long mode = enabled ? 0 : 1;
-  if (ioctlsocket(m_sd, FIONBIO, &mode) == SOCKET_ERROR) {
-    return false;
-  }
-#else
-  int flags = fcntl(m_sd, F_GETFL, nullptr);
-  if (flags < 0) {
-    return false;
-  }
-  if (enabled) {
-    flags &= ~O_NONBLOCK;
-  } else {
-    flags |= O_NONBLOCK;
-  }
-  if (fcntl(m_sd, F_SETFL, flags) < 0) {
-    return false;
-  }
-#endif
-  return true;
-}
-
-int TCPStream::getNativeHandle() const {
-  return m_sd;
-}
-
-bool TCPStream::WaitForReadEvent(int timeout) {
-  fd_set sdset;
-  struct timeval tv;
-
-  tv.tv_sec = timeout;
-  tv.tv_usec = 0;
-  FD_ZERO(&sdset);
-  FD_SET(m_sd, &sdset);
-  if (select(m_sd + 1, &sdset, nullptr, nullptr, &tv) > 0) {
-    return true;
-  }
-  return false;
-}
diff --git a/wpiutil/src/main/native/cpp/UDPClient.cpp b/wpiutil/src/main/native/cpp/UDPClient.cpp
deleted file mode 100644
index 108ef54..0000000
--- a/wpiutil/src/main/native/cpp/UDPClient.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/UDPClient.h"
-
-#ifdef _WIN32
-#include <WinSock2.h>
-#include <Ws2tcpip.h>
-#pragma comment(lib, "Ws2_32.lib")
-#else
-#include <arpa/inet.h>
-#include <fcntl.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#endif
-
-#include "wpi/Logger.h"
-#include "wpi/SmallString.h"
-#include "wpi/SocketError.h"
-
-using namespace wpi;
-
-UDPClient::UDPClient(Logger& logger) : UDPClient("", logger) {}
-
-UDPClient::UDPClient(std::string_view address, Logger& logger)
-    : m_lsd(0), m_port(0), m_address(address), m_logger(logger) {}
-
-UDPClient::UDPClient(UDPClient&& other)
-    : m_lsd(other.m_lsd),
-      m_port(other.m_port),
-      m_address(std::move(other.m_address)),
-      m_logger(other.m_logger) {
-  other.m_lsd = 0;
-  other.m_port = 0;
-}
-
-UDPClient::~UDPClient() {
-  if (m_lsd > 0) {
-    shutdown();
-  }
-}
-
-UDPClient& UDPClient::operator=(UDPClient&& other) {
-  if (this == &other) {
-    return *this;
-  }
-  shutdown();
-  m_logger = other.m_logger;
-  m_lsd = other.m_lsd;
-  m_address = std::move(other.m_address);
-  m_port = other.m_port;
-  other.m_lsd = 0;
-  other.m_port = 0;
-  return *this;
-}
-
-int UDPClient::start() {
-  return start(0);
-}
-
-int UDPClient::start(int port) {
-  if (m_lsd > 0) {
-    return 0;
-  }
-
-#ifdef _WIN32
-  WSAData wsaData;
-  WORD wVersionRequested = MAKEWORD(2, 2);
-  WSAStartup(wVersionRequested, &wsaData);
-#endif
-
-  m_lsd = socket(AF_INET, SOCK_DGRAM, 0);
-
-  if (m_lsd < 0) {
-    WPI_ERROR(m_logger, "{}", "could not create socket");
-    return -1;
-  }
-
-  struct sockaddr_in addr;
-  std::memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  if (m_address.size() > 0) {
-#ifdef _WIN32
-    SmallString<128> addr_copy(m_address);
-    addr_copy.push_back('\0');
-    int res = InetPton(PF_INET, addr_copy.data(), &(addr.sin_addr));
-#else
-    int res = inet_pton(PF_INET, m_address.c_str(), &(addr.sin_addr));
-#endif
-    if (res != 1) {
-      WPI_ERROR(m_logger, "could not resolve {} address", m_address);
-      return -1;
-    }
-  } else {
-    addr.sin_addr.s_addr = INADDR_ANY;
-  }
-  addr.sin_port = htons(port);
-
-  if (port != 0) {
-#ifdef _WIN32
-    int optval = 1;
-    setsockopt(m_lsd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-               reinterpret_cast<char*>(&optval), sizeof optval);
-#else
-    int optval = 1;
-    setsockopt(m_lsd, SOL_SOCKET, SO_REUSEADDR,
-               reinterpret_cast<char*>(&optval), sizeof optval);
-#endif
-  }
-
-  int result = bind(m_lsd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
-  if (result != 0) {
-    WPI_ERROR(m_logger, "bind() failed: {}", SocketStrerror());
-    return result;
-  }
-  m_port = port;
-  return 0;
-}
-
-void UDPClient::shutdown() {
-  if (m_lsd > 0) {
-#ifdef _WIN32
-    ::shutdown(m_lsd, SD_BOTH);
-    closesocket(m_lsd);
-    WSACleanup();
-#else
-    ::shutdown(m_lsd, SHUT_RDWR);
-    close(m_lsd);
-#endif
-    m_lsd = 0;
-    m_port = 0;
-  }
-}
-
-int UDPClient::send(span<const uint8_t> data, std::string_view server,
-                    int port) {
-  // server must be a resolvable IP address
-  struct sockaddr_in addr;
-  std::memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  SmallString<128> remoteAddr{server};
-  if (remoteAddr.empty()) {
-    WPI_ERROR(m_logger, "{}", "server must be passed");
-    return -1;
-  }
-
-#ifdef _WIN32
-  int res = InetPton(AF_INET, remoteAddr.c_str(), &(addr.sin_addr));
-#else
-  int res = inet_pton(AF_INET, remoteAddr.c_str(), &(addr.sin_addr));
-#endif
-  if (res != 1) {
-    WPI_ERROR(m_logger, "could not resolve {} address", server);
-    return -1;
-  }
-  addr.sin_port = htons(port);
-
-  // sendto should not block
-  int result =
-      sendto(m_lsd, reinterpret_cast<const char*>(data.data()), data.size(), 0,
-             reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
-  return result;
-}
-
-int UDPClient::send(std::string_view data, std::string_view server, int port) {
-  // server must be a resolvable IP address
-  struct sockaddr_in addr;
-  std::memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  SmallString<128> remoteAddr{server};
-  if (remoteAddr.empty()) {
-    WPI_ERROR(m_logger, "{}", "server must be passed");
-    return -1;
-  }
-
-#ifdef _WIN32
-  int res = InetPton(AF_INET, remoteAddr.c_str(), &(addr.sin_addr));
-#else
-  int res = inet_pton(AF_INET, remoteAddr.c_str(), &(addr.sin_addr));
-#endif
-  if (res != 1) {
-    WPI_ERROR(m_logger, "could not resolve {} address", server);
-    return -1;
-  }
-  addr.sin_port = htons(port);
-
-  // sendto should not block
-  int result = sendto(m_lsd, data.data(), data.size(), 0,
-                      reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
-  return result;
-}
-
-int UDPClient::receive(uint8_t* data_received, int receive_len) {
-  if (m_port == 0) {
-    return -1;  // return if not receiving
-  }
-  return recv(m_lsd, reinterpret_cast<char*>(data_received), receive_len, 0);
-}
-
-int UDPClient::receive(uint8_t* data_received, int receive_len,
-                       SmallVectorImpl<char>* addr_received,
-                       int* port_received) {
-  if (m_port == 0) {
-    return -1;  // return if not receiving
-  }
-
-  struct sockaddr_in remote;
-  socklen_t remote_len = sizeof(remote);
-  std::memset(&remote, 0, sizeof(remote));
-
-  int result =
-      recvfrom(m_lsd, reinterpret_cast<char*>(data_received), receive_len, 0,
-               reinterpret_cast<sockaddr*>(&remote), &remote_len);
-
-  char ip[50];
-#ifdef _WIN32
-  InetNtop(PF_INET, &(remote.sin_addr.s_addr), ip, sizeof(ip) - 1);
-#else
-  inet_ntop(PF_INET, reinterpret_cast<in_addr*>(&(remote.sin_addr.s_addr)), ip,
-            sizeof(ip) - 1);
-#endif
-
-  ip[49] = '\0';
-  int addr_len = std::strlen(ip);
-  addr_received->clear();
-  addr_received->append(&ip[0], &ip[addr_len]);
-
-  *port_received = ntohs(remote.sin_port);
-
-  return result;
-}
-
-int UDPClient::set_timeout(double timeout) {
-  if (timeout < 0) {
-    return -1;
-  }
-  struct timeval tv;
-  tv.tv_sec = timeout;             // truncating will give seconds
-  timeout -= tv.tv_sec;            // remove seconds portion
-  tv.tv_usec = timeout * 1000000;  // fractions of a second to us
-  int ret = setsockopt(m_lsd, SOL_SOCKET, SO_RCVTIMEO,
-                       reinterpret_cast<char*>(&tv), sizeof(tv));
-  if (ret < 0) {
-    WPI_ERROR(m_logger, "{}", "set timeout failed");
-  }
-  return ret;
-}
diff --git a/wpiutil/src/main/native/cpp/WebSocket.cpp b/wpiutil/src/main/native/cpp/WebSocket.cpp
deleted file mode 100644
index 4bb49d3..0000000
--- a/wpiutil/src/main/native/cpp/WebSocket.cpp
+++ /dev/null
@@ -1,656 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocket.h"
-
-#include <random>
-
-#include "fmt/format.h"
-#include "wpi/Base64.h"
-#include "wpi/HttpParser.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringExtras.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/sha1.h"
-#include "wpi/uv/Stream.h"
-
-using namespace wpi;
-
-namespace {
-class WebSocketWriteReq : public uv::WriteReq {
- public:
-  explicit WebSocketWriteReq(
-      std::function<void(span<uv::Buffer>, uv::Error)> callback)
-      : m_callback{std::move(callback)} {
-    finish.connect([this](uv::Error err) {
-      span<uv::Buffer> bufs{m_bufs};
-      for (auto&& buf : bufs.subspan(0, m_startUser)) {
-        buf.Deallocate();
-      }
-      m_callback(bufs.subspan(m_startUser), err);
-    });
-  }
-
-  std::function<void(span<uv::Buffer>, uv::Error)> m_callback;
-  SmallVector<uv::Buffer, 4> m_bufs;
-  size_t m_startUser;
-};
-}  // namespace
-
-class WebSocket::ClientHandshakeData {
- public:
-  ClientHandshakeData() {
-    // key is a random nonce
-    static std::random_device rd;
-    static std::default_random_engine gen{rd()};
-    std::uniform_int_distribution<unsigned int> dist(0, 255);
-    char nonce[16];  // the nonce sent to the server
-    for (char& v : nonce) {
-      v = static_cast<char>(dist(gen));
-    }
-    raw_svector_ostream os(key);
-    Base64Encode(os, {nonce, 16});
-  }
-  ~ClientHandshakeData() {
-    if (auto t = timer.lock()) {
-      t->Stop();
-      t->Close();
-    }
-  }
-
-  SmallString<64> key;                       // the key sent to the server
-  SmallVector<std::string, 2> protocols;     // valid protocols
-  HttpParser parser{HttpParser::kResponse};  // server response parser
-  bool hasUpgrade = false;
-  bool hasConnection = false;
-  bool hasAccept = false;
-  bool hasProtocol = false;
-
-  std::weak_ptr<uv::Timer> timer;
-};
-
-static std::string_view AcceptHash(std::string_view key,
-                                   SmallVectorImpl<char>& buf) {
-  SHA1 hash;
-  hash.Update(key);
-  hash.Update("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
-  SmallString<64> hashBuf;
-  return Base64Encode(hash.RawFinal(hashBuf), buf);
-}
-
-WebSocket::WebSocket(uv::Stream& stream, bool server, const private_init&)
-    : m_stream{stream}, m_server{server} {
-  // Connect closed and error signals to ourselves
-  m_stream.closed.connect([this]() { SetClosed(1006, "handle closed"); });
-  m_stream.error.connect([this](uv::Error err) {
-    Terminate(1006, fmt::format("stream error: {}", err.name()));
-  });
-
-  // Start reading
-  m_stream.StopRead();  // we may have been reading
-  m_stream.StartRead();
-  m_stream.data.connect(
-      [this](uv::Buffer& buf, size_t size) { HandleIncoming(buf, size); });
-  m_stream.end.connect(
-      [this]() { Terminate(1006, "remote end closed connection"); });
-}
-
-WebSocket::~WebSocket() = default;
-
-std::shared_ptr<WebSocket> WebSocket::CreateClient(
-    uv::Stream& stream, std::string_view uri, std::string_view host,
-    span<const std::string_view> protocols, const ClientOptions& options) {
-  auto ws = std::make_shared<WebSocket>(stream, false, private_init{});
-  stream.SetData(ws);
-  ws->StartClient(uri, host, protocols, options);
-  return ws;
-}
-
-std::shared_ptr<WebSocket> WebSocket::CreateServer(uv::Stream& stream,
-                                                   std::string_view key,
-                                                   std::string_view version,
-                                                   std::string_view protocol) {
-  auto ws = std::make_shared<WebSocket>(stream, true, private_init{});
-  stream.SetData(ws);
-  ws->StartServer(key, version, protocol);
-  return ws;
-}
-
-void WebSocket::Close(uint16_t code, std::string_view reason) {
-  SendClose(code, reason);
-  if (m_state != FAILED && m_state != CLOSED) {
-    m_state = CLOSING;
-  }
-}
-
-void WebSocket::Fail(uint16_t code, std::string_view reason) {
-  if (m_state == FAILED || m_state == CLOSED) {
-    return;
-  }
-  SendClose(code, reason);
-  SetClosed(code, reason, true);
-  Shutdown();
-}
-
-void WebSocket::Terminate(uint16_t code, std::string_view reason) {
-  if (m_state == FAILED || m_state == CLOSED) {
-    return;
-  }
-  SetClosed(code, reason);
-  Shutdown();
-}
-
-void WebSocket::StartClient(std::string_view uri, std::string_view host,
-                            span<const std::string_view> protocols,
-                            const ClientOptions& options) {
-  // Create client handshake data
-  m_clientHandshake = std::make_unique<ClientHandshakeData>();
-
-  // Build client request
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, 4096};
-
-  os << "GET " << uri << " HTTP/1.1\r\n";
-  os << "Host: " << host << "\r\n";
-  os << "Upgrade: websocket\r\n";
-  os << "Connection: Upgrade\r\n";
-  os << "Sec-WebSocket-Key: " << m_clientHandshake->key << "\r\n";
-  os << "Sec-WebSocket-Version: 13\r\n";
-
-  // protocols (if provided)
-  if (!protocols.empty()) {
-    os << "Sec-WebSocket-Protocol: ";
-    bool first = true;
-    for (auto protocol : protocols) {
-      if (!first) {
-        os << ", ";
-      } else {
-        first = false;
-      }
-      os << protocol;
-      // also save for later checking against server response
-      m_clientHandshake->protocols.emplace_back(protocol);
-    }
-    os << "\r\n";
-  }
-
-  // other headers
-  for (auto&& header : options.extraHeaders) {
-    os << header.first << ": " << header.second << "\r\n";
-  }
-
-  // finish headers
-  os << "\r\n";
-
-  // Send client request
-  m_stream.Write(bufs, [](auto bufs, uv::Error) {
-    for (auto& buf : bufs) {
-      buf.Deallocate();
-    }
-  });
-
-  // Set up client response handling
-  m_clientHandshake->parser.status.connect([this](std::string_view status) {
-    unsigned int code = m_clientHandshake->parser.GetStatusCode();
-    if (code != 101) {
-      Terminate(code, status);
-    }
-  });
-  m_clientHandshake->parser.header.connect(
-      [this](std::string_view name, std::string_view value) {
-        value = trim(value);
-        if (equals_lower(name, "upgrade")) {
-          if (!equals_lower(value, "websocket")) {
-            return Terminate(1002, "invalid upgrade response value");
-          }
-          m_clientHandshake->hasUpgrade = true;
-        } else if (equals_lower(name, "connection")) {
-          if (!equals_lower(value, "upgrade")) {
-            return Terminate(1002, "invalid connection response value");
-          }
-          m_clientHandshake->hasConnection = true;
-        } else if (equals_lower(name, "sec-websocket-accept")) {
-          // Check against expected response
-          SmallString<64> acceptBuf;
-          if (!equals(value, AcceptHash(m_clientHandshake->key, acceptBuf))) {
-            return Terminate(1002, "invalid accept key");
-          }
-          m_clientHandshake->hasAccept = true;
-        } else if (equals_lower(name, "sec-websocket-extensions")) {
-          // No extensions are supported
-          if (!value.empty()) {
-            return Terminate(1010, "unsupported extension");
-          }
-        } else if (equals_lower(name, "sec-websocket-protocol")) {
-          // Make sure it was one of the provided protocols
-          bool match = false;
-          for (auto&& protocol : m_clientHandshake->protocols) {
-            if (equals_lower(value, protocol)) {
-              match = true;
-              break;
-            }
-          }
-          if (!match) {
-            return Terminate(1003, "unsupported protocol");
-          }
-          m_clientHandshake->hasProtocol = true;
-          m_protocol = value;
-        }
-      });
-  m_clientHandshake->parser.headersComplete.connect([this](bool) {
-    if (!m_clientHandshake->hasUpgrade || !m_clientHandshake->hasConnection ||
-        !m_clientHandshake->hasAccept ||
-        (!m_clientHandshake->hasProtocol &&
-         !m_clientHandshake->protocols.empty())) {
-      return Terminate(1002, "invalid response");
-    }
-    if (m_state == CONNECTING) {
-      m_state = OPEN;
-      open(m_protocol);
-    }
-  });
-
-  // Start handshake timer if a timeout was specified
-  if (options.handshakeTimeout != (uv::Timer::Time::max)()) {
-    auto timer = uv::Timer::Create(m_stream.GetLoopRef());
-    timer->timeout.connect(
-        [this]() { Terminate(1006, "connection timed out"); });
-    timer->Start(options.handshakeTimeout);
-    m_clientHandshake->timer = timer;
-  }
-}
-
-void WebSocket::StartServer(std::string_view key, std::string_view version,
-                            std::string_view protocol) {
-  m_protocol = protocol;
-
-  // Build server response
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, 4096};
-
-  // Handle unsupported version
-  if (version != "13") {
-    os << "HTTP/1.1 426 Upgrade Required\r\n";
-    os << "Upgrade: WebSocket\r\n";
-    os << "Sec-WebSocket-Version: 13\r\n\r\n";
-    m_stream.Write(bufs, [this](auto bufs, uv::Error) {
-      for (auto& buf : bufs) {
-        buf.Deallocate();
-      }
-      // XXX: Should we support sending a new handshake on the same connection?
-      // XXX: "this->" is required by GCC 5.5 (bug)
-      this->Terminate(1003, "unsupported protocol version");
-    });
-    return;
-  }
-
-  os << "HTTP/1.1 101 Switching Protocols\r\n";
-  os << "Upgrade: websocket\r\n";
-  os << "Connection: Upgrade\r\n";
-
-  // accept hash
-  SmallString<64> acceptBuf;
-  os << "Sec-WebSocket-Accept: " << AcceptHash(key, acceptBuf) << "\r\n";
-
-  if (!protocol.empty()) {
-    os << "Sec-WebSocket-Protocol: " << protocol << "\r\n";
-  }
-
-  // end headers
-  os << "\r\n";
-
-  // Send server response
-  m_stream.Write(bufs, [this](auto bufs, uv::Error) {
-    for (auto& buf : bufs) {
-      buf.Deallocate();
-    }
-    if (m_state == CONNECTING) {
-      m_state = OPEN;
-      open(m_protocol);
-    }
-  });
-}
-
-void WebSocket::SendClose(uint16_t code, std::string_view reason) {
-  SmallVector<uv::Buffer, 4> bufs;
-  if (code != 1005) {
-    raw_uv_ostream os{bufs, 4096};
-    const uint8_t codeMsb[] = {static_cast<uint8_t>((code >> 8) & 0xff),
-                               static_cast<uint8_t>(code & 0xff)};
-    os << span{codeMsb};
-    os << reason;
-  }
-  Send(kFlagFin | kOpClose, bufs, [](auto bufs, uv::Error) {
-    for (auto&& buf : bufs) {
-      buf.Deallocate();
-    }
-  });
-}
-
-void WebSocket::SetClosed(uint16_t code, std::string_view reason, bool failed) {
-  if (m_state == FAILED || m_state == CLOSED) {
-    return;
-  }
-  m_state = failed ? FAILED : CLOSED;
-  closed(code, reason);
-}
-
-void WebSocket::Shutdown() {
-  m_stream.Shutdown([this] { m_stream.Close(); });
-}
-
-void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
-  // ignore incoming data if we're failed or closed
-  if (m_state == FAILED || m_state == CLOSED) {
-    return;
-  }
-
-  std::string_view data{buf.base, size};
-
-  // Handle connecting state (mainly on client)
-  if (m_state == CONNECTING) {
-    if (m_clientHandshake) {
-      data = m_clientHandshake->parser.Execute(data);
-      // check for parser failure
-      if (m_clientHandshake->parser.HasError()) {
-        return Terminate(1003, "invalid response");
-      }
-      if (m_state != OPEN) {
-        return;  // not done with handshake yet
-      }
-
-      // we're done with the handshake, so release its memory
-      m_clientHandshake.reset();
-
-      // fall through to process additional data after handshake
-    } else {
-      return Terminate(1003, "got data on server before response");
-    }
-  }
-
-  // Message processing
-  while (!data.empty()) {
-    if (m_frameSize == UINT64_MAX) {
-      // Need at least two bytes to determine header length
-      if (m_header.size() < 2u) {
-        size_t toCopy = (std::min)(2u - m_header.size(), data.size());
-        m_header.append(data.data(), data.data() + toCopy);
-        data.remove_prefix(toCopy);
-        if (m_header.size() < 2u) {
-          return;  // need more data
-        }
-
-        // Validate RSV bits are zero
-        if ((m_header[0] & 0x70) != 0) {
-          return Fail(1002, "nonzero RSV");
-        }
-      }
-
-      // Once we have first two bytes, we can calculate the header size
-      if (m_headerSize == 0) {
-        m_headerSize = 2;
-        uint8_t len = m_header[1] & kLenMask;
-        if (len == 126) {
-          m_headerSize += 2;
-        } else if (len == 127) {
-          m_headerSize += 8;
-        }
-        bool masking = (m_header[1] & kFlagMasking) != 0;
-        if (masking) {
-          m_headerSize += 4;  // masking key
-        }
-        // On server side, incoming messages MUST be masked
-        // On client side, incoming messages MUST NOT be masked
-        if (m_server && !masking) {
-          return Fail(1002, "client data not masked");
-        }
-        if (!m_server && masking) {
-          return Fail(1002, "server data masked");
-        }
-      }
-
-      // Need to complete header to calculate message size
-      if (m_header.size() < m_headerSize) {
-        size_t toCopy = (std::min)(m_headerSize - m_header.size(), data.size());
-        m_header.append(data.data(), data.data() + toCopy);
-        data.remove_prefix(toCopy);
-        if (m_header.size() < m_headerSize) {
-          return;  // need more data
-        }
-      }
-
-      if (m_header.size() >= m_headerSize) {
-        // get payload length
-        uint8_t len = m_header[1] & kLenMask;
-        if (len == 126) {
-          m_frameSize = (static_cast<uint16_t>(m_header[2]) << 8) |
-                        static_cast<uint16_t>(m_header[3]);
-        } else if (len == 127) {
-          m_frameSize = (static_cast<uint64_t>(m_header[2]) << 56) |
-                        (static_cast<uint64_t>(m_header[3]) << 48) |
-                        (static_cast<uint64_t>(m_header[4]) << 40) |
-                        (static_cast<uint64_t>(m_header[5]) << 32) |
-                        (static_cast<uint64_t>(m_header[6]) << 24) |
-                        (static_cast<uint64_t>(m_header[7]) << 16) |
-                        (static_cast<uint64_t>(m_header[8]) << 8) |
-                        static_cast<uint64_t>(m_header[9]);
-        } else {
-          m_frameSize = len;
-        }
-
-        // limit maximum size
-        if ((m_payload.size() + m_frameSize) > m_maxMessageSize) {
-          return Fail(1009, "message too large");
-        }
-      }
-    }
-
-    if (m_frameSize != UINT64_MAX) {
-      size_t need = m_frameStart + m_frameSize - m_payload.size();
-      size_t toCopy = (std::min)(need, data.size());
-      m_payload.append(data.data(), data.data() + toCopy);
-      data.remove_prefix(toCopy);
-      need -= toCopy;
-      if (need == 0) {
-        // We have a complete frame
-        // If the message had masking, unmask it
-        if ((m_header[1] & kFlagMasking) != 0) {
-          uint8_t key[4] = {
-              m_header[m_headerSize - 4], m_header[m_headerSize - 3],
-              m_header[m_headerSize - 2], m_header[m_headerSize - 1]};
-          int n = 0;
-          for (uint8_t& ch : span{m_payload}.subspan(m_frameStart)) {
-            ch ^= key[n++];
-            if (n >= 4) {
-              n = 0;
-            }
-          }
-        }
-
-        // Handle message
-        bool fin = (m_header[0] & kFlagFin) != 0;
-        uint8_t opcode = m_header[0] & kOpMask;
-        switch (opcode) {
-          case kOpCont:
-            switch (m_fragmentOpcode) {
-              case kOpText:
-                if (!m_combineFragments || fin) {
-                  text(std::string_view{reinterpret_cast<char*>(
-                                            m_payload.data()),
-                                        m_payload.size()},
-                       fin);
-                }
-                break;
-              case kOpBinary:
-                if (!m_combineFragments || fin) {
-                  binary(m_payload, fin);
-                }
-                break;
-              default:
-                // no preceding message?
-                return Fail(1002, "invalid continuation message");
-            }
-            if (fin) {
-              m_fragmentOpcode = 0;
-            }
-            break;
-          case kOpText:
-            if (m_fragmentOpcode != 0) {
-              return Fail(1002, "incomplete fragment");
-            }
-            if (!m_combineFragments || fin) {
-              text(std::string_view{reinterpret_cast<char*>(m_payload.data()),
-                                    m_payload.size()},
-                   fin);
-            }
-            if (!fin) {
-              m_fragmentOpcode = opcode;
-            }
-            break;
-          case kOpBinary:
-            if (m_fragmentOpcode != 0) {
-              return Fail(1002, "incomplete fragment");
-            }
-            if (!m_combineFragments || fin) {
-              binary(m_payload, fin);
-            }
-            if (!fin) {
-              m_fragmentOpcode = opcode;
-            }
-            break;
-          case kOpClose: {
-            uint16_t code;
-            std::string_view reason;
-            if (!fin) {
-              code = 1002;
-              reason = "cannot fragment control frames";
-            } else if (m_payload.size() < 2) {
-              code = 1005;
-            } else {
-              code = (static_cast<uint16_t>(m_payload[0]) << 8) |
-                     static_cast<uint16_t>(m_payload[1]);
-              reason = drop_front(
-                  {reinterpret_cast<char*>(m_payload.data()), m_payload.size()},
-                  2);
-            }
-            // Echo the close if we didn't previously send it
-            if (m_state != CLOSING) {
-              SendClose(code, reason);
-            }
-            SetClosed(code, reason);
-            // If we're the server, shutdown the connection.
-            if (m_server) {
-              Shutdown();
-            }
-            break;
-          }
-          case kOpPing:
-            if (!fin) {
-              return Fail(1002, "cannot fragment control frames");
-            }
-            ping(m_payload);
-            break;
-          case kOpPong:
-            if (!fin) {
-              return Fail(1002, "cannot fragment control frames");
-            }
-            pong(m_payload);
-            break;
-          default:
-            return Fail(1002, "invalid message opcode");
-        }
-
-        // Prepare for next message
-        m_header.clear();
-        m_headerSize = 0;
-        if (!m_combineFragments || fin) {
-          m_payload.clear();
-        }
-        m_frameStart = m_payload.size();
-        m_frameSize = UINT64_MAX;
-      }
-    }
-  }
-}
-
-void WebSocket::Send(
-    uint8_t opcode, span<const uv::Buffer> data,
-    std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-  // If we're not open, emit an error and don't send the data
-  if (m_state != OPEN) {
-    int err;
-    if (m_state == CONNECTING) {
-      err = UV_EAGAIN;
-    } else {
-      err = UV_ESHUTDOWN;
-    }
-    SmallVector<uv::Buffer, 4> bufs{data.begin(), data.end()};
-    callback(bufs, uv::Error{err});
-    return;
-  }
-
-  auto req = std::make_shared<WebSocketWriteReq>(std::move(callback));
-  raw_uv_ostream os{req->m_bufs, 4096};
-
-  // opcode (includes FIN bit)
-  os << static_cast<unsigned char>(opcode);
-
-  // payload length
-  uint64_t size = 0;
-  for (auto&& buf : data) {
-    size += buf.len;
-  }
-  if (size < 126) {
-    os << static_cast<unsigned char>((m_server ? 0x00 : kFlagMasking) | size);
-  } else if (size <= 0xffff) {
-    os << static_cast<unsigned char>((m_server ? 0x00 : kFlagMasking) | 126);
-    const uint8_t sizeMsb[] = {static_cast<uint8_t>((size >> 8) & 0xff),
-                               static_cast<uint8_t>(size & 0xff)};
-    os << span{sizeMsb};
-  } else {
-    os << static_cast<unsigned char>((m_server ? 0x00 : kFlagMasking) | 127);
-    const uint8_t sizeMsb[] = {static_cast<uint8_t>((size >> 56) & 0xff),
-                               static_cast<uint8_t>((size >> 48) & 0xff),
-                               static_cast<uint8_t>((size >> 40) & 0xff),
-                               static_cast<uint8_t>((size >> 32) & 0xff),
-                               static_cast<uint8_t>((size >> 24) & 0xff),
-                               static_cast<uint8_t>((size >> 16) & 0xff),
-                               static_cast<uint8_t>((size >> 8) & 0xff),
-                               static_cast<uint8_t>(size & 0xff)};
-    os << span{sizeMsb};
-  }
-
-  // clients need to mask the input data
-  if (!m_server) {
-    // generate masking key
-    static std::random_device rd;
-    static std::default_random_engine gen{rd()};
-    std::uniform_int_distribution<unsigned int> dist(0, 255);
-    uint8_t key[4];
-    for (uint8_t& v : key) {
-      v = dist(gen);
-    }
-    os << span<const uint8_t>{key, 4};
-    // copy and mask data
-    int n = 0;
-    for (auto&& buf : data) {
-      for (auto&& ch : buf.data()) {
-        os << static_cast<unsigned char>(static_cast<uint8_t>(ch) ^ key[n++]);
-        if (n >= 4) {
-          n = 0;
-        }
-      }
-    }
-    req->m_startUser = req->m_bufs.size();
-    req->m_bufs.append(data.begin(), data.end());
-    // don't send the user bufs as we copied their data
-    m_stream.Write(span{req->m_bufs}.subspan(0, req->m_startUser), req);
-  } else {
-    // servers can just send the buffers directly without masking
-    req->m_startUser = req->m_bufs.size();
-    req->m_bufs.append(data.begin(), data.end());
-    m_stream.Write(req->m_bufs, req);
-  }
-}
diff --git a/wpiutil/src/main/native/cpp/WebSocketServer.cpp b/wpiutil/src/main/native/cpp/WebSocketServer.cpp
deleted file mode 100644
index 1562f3b..0000000
--- a/wpiutil/src/main/native/cpp/WebSocketServer.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocketServer.h"
-
-#include <utility>
-
-#include "wpi/StringExtras.h"
-#include "wpi/fmt/raw_ostream.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/uv/Buffer.h"
-#include "wpi/uv/Stream.h"
-
-using namespace wpi;
-
-WebSocketServerHelper::WebSocketServerHelper(HttpParser& req) {
-  req.header.connect([this](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "host")) {
-      m_gotHost = true;
-    } else if (equals_lower(name, "upgrade")) {
-      if (equals_lower(value, "websocket")) {
-        m_websocket = true;
-      }
-    } else if (equals_lower(name, "sec-websocket-key")) {
-      m_key = value;
-    } else if (equals_lower(name, "sec-websocket-version")) {
-      m_version = value;
-    } else if (equals_lower(name, "sec-websocket-protocol")) {
-      // Protocols are comma delimited, repeated headers add to list
-      SmallVector<std::string_view, 2> protocols;
-      split(value, protocols, ",", -1, false);
-      for (auto protocol : protocols) {
-        protocol = trim(protocol);
-        if (!protocol.empty()) {
-          m_protocols.emplace_back(protocol);
-        }
-      }
-    }
-  });
-  req.headersComplete.connect([&req, this](bool) {
-    if (req.IsUpgrade() && IsUpgrade()) {
-      upgrade();
-    }
-  });
-}
-
-std::pair<bool, std::string_view> WebSocketServerHelper::MatchProtocol(
-    span<const std::string_view> protocols) {
-  if (protocols.empty() && m_protocols.empty()) {
-    return {true, {}};
-  }
-  for (auto protocol : protocols) {
-    for (auto&& clientProto : m_protocols) {
-      if (protocol == clientProto) {
-        return {true, protocol};
-      }
-    }
-  }
-  return {false, {}};
-}
-
-WebSocketServer::WebSocketServer(uv::Stream& stream,
-                                 span<const std::string_view> protocols,
-                                 ServerOptions options, const private_init&)
-    : m_stream{stream},
-      m_helper{m_req},
-      m_protocols{protocols.begin(), protocols.end()},
-      m_options{std::move(options)} {
-  // Header handling
-  m_req.header.connect([this](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "host")) {
-      if (m_options.checkHost) {
-        if (!m_options.checkHost(value)) {
-          Abort(401, "Unrecognized Host");
-        }
-      }
-    }
-  });
-  m_req.url.connect([this](std::string_view name) {
-    if (m_options.checkUrl) {
-      if (!m_options.checkUrl(name)) {
-        Abort(404, "Not Found");
-      }
-    }
-  });
-  m_req.headersComplete.connect([this](bool) {
-    // We only accept websocket connections
-    if (!m_helper.IsUpgrade() || !m_req.IsUpgrade()) {
-      Abort(426, "Upgrade Required");
-    }
-  });
-
-  // Handle upgrade event
-  m_helper.upgrade.connect([this] {
-    if (m_aborted) {
-      return;
-    }
-
-    // Negotiate sub-protocol
-    SmallVector<std::string_view, 2> protocols{m_protocols.begin(),
-                                               m_protocols.end()};
-    std::string_view protocol = m_helper.MatchProtocol(protocols).second;
-
-    // Disconnect our header reader
-    m_dataConn.disconnect();
-
-    // Accepting the stream may destroy this (as it replaces the stream user
-    // data), so grab a shared pointer first.
-    auto self = shared_from_this();
-
-    // Accept the upgrade
-    auto ws = m_helper.Accept(m_stream, protocol);
-
-    // Connect the websocket open event to our connected event.
-    ws->open.connect_extended(
-        [self, s = ws.get()](auto conn, std::string_view) {
-          self->connected(self->m_req.GetUrl(), *s);
-          conn.disconnect();  // one-shot
-        });
-  });
-
-  // Set up stream
-  stream.StartRead();
-  m_dataConn =
-      stream.data.connect_connection([this](uv::Buffer& buf, size_t size) {
-        if (m_aborted) {
-          return;
-        }
-        m_req.Execute(std::string_view{buf.base, size});
-        if (m_req.HasError()) {
-          Abort(400, "Bad Request");
-        }
-      });
-  m_errorConn =
-      stream.error.connect_connection([this](uv::Error) { m_stream.Close(); });
-  m_endConn = stream.end.connect_connection([this] { m_stream.Close(); });
-}
-
-std::shared_ptr<WebSocketServer> WebSocketServer::Create(
-    uv::Stream& stream, span<const std::string_view> protocols,
-    const ServerOptions& options) {
-  auto server = std::make_shared<WebSocketServer>(stream, protocols, options,
-                                                  private_init{});
-  stream.SetData(server);
-  return server;
-}
-
-void WebSocketServer::Abort(uint16_t code, std::string_view reason) {
-  if (m_aborted) {
-    return;
-  }
-  m_aborted = true;
-
-  // Build response
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os{bufs, 1024};
-
-  // Handle unsupported version
-  fmt::print(os, "HTTP/1.1 {} {}\r\n", code, reason);
-  if (code == 426) {
-    os << "Upgrade: WebSocket\r\n";
-  }
-  os << "\r\n";
-  m_stream.Write(bufs, [this](auto bufs, uv::Error) {
-    for (auto& buf : bufs) {
-      buf.Deallocate();
-    }
-    m_stream.Shutdown([this] { m_stream.Close(); });
-  });
-}
diff --git a/wpiutil/src/main/native/cpp/fs.cpp b/wpiutil/src/main/native/cpp/fs.cpp
index 34d6cca..fad6a66 100644
--- a/wpiutil/src/main/native/cpp/fs.cpp
+++ b/wpiutil/src/main/native/cpp/fs.cpp
@@ -82,17 +82,6 @@
 const file_t kInvalidFile = INVALID_HANDLE_VALUE;
 
 static DWORD nativeDisposition(CreationDisposition Disp, OpenFlags Flags) {
-  // This is a compatibility hack.  Really we should respect the creation
-  // disposition, but a lot of old code relied on the implicit assumption that
-  // OF_Append implied it would open an existing file.  Since the disposition is
-  // now explicit and defaults to CD_CreateAlways, this assumption would cause
-  // any usage of OF_Append to append to a new file, even if the file already
-  // existed.  A better solution might have two new creation dispositions:
-  // CD_AppendAlways and CD_AppendNew.  This would also address the problem of
-  // OF_Append being used on a read-only descriptor, which doesn't make sense.
-  if (Flags & OF_Append)
-    return OPEN_ALWAYS;
-
   switch (Disp) {
     case CD_CreateAlways:
       return CREATE_ALWAYS;
@@ -251,12 +240,6 @@
     Result |= O_RDWR;
   }
 
-  // This is for compatibility with old code that assumed F_Append implied
-  // would open an existing file.  See Windows/Path.inc for a longer comment.
-  if (Flags & F_Append) {
-    Disp = CD_OpenAlways;
-  }
-
   if (Disp == CD_CreateNew) {
     Result |= O_CREAT;  // Create if it doesn't exist.
     Result |= O_EXCL;   // Fail if it does.
diff --git a/wpiutil/src/main/native/cpp/hostname.cpp b/wpiutil/src/main/native/cpp/hostname.cpp
deleted file mode 100644
index d907023..0000000
--- a/wpiutil/src/main/native/cpp/hostname.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/hostname.h"
-
-#include <cstdlib>
-#include <string>
-#include <string_view>
-
-#include "uv.h"
-#include "wpi/SmallVector.h"
-
-namespace wpi {
-
-std::string GetHostname() {
-  std::string rv;
-  char name[256];
-  size_t size = sizeof(name);
-
-  int err = uv_os_gethostname(name, &size);
-  if (err == 0) {
-    rv.assign(name, size);
-  } else if (err == UV_ENOBUFS) {
-    char* name2 = static_cast<char*>(std::malloc(size));
-    err = uv_os_gethostname(name2, &size);
-    if (err == 0) {
-      rv.assign(name2, size);
-    }
-    std::free(name2);
-  }
-
-  return rv;
-}
-
-std::string_view GetHostname(SmallVectorImpl<char>& name) {
-  // Use a tmp array to not require the SmallVector to be too large.
-  char tmpName[256];
-  size_t size = sizeof(tmpName);
-
-  name.clear();
-
-  int err = uv_os_gethostname(tmpName, &size);
-  if (err == 0) {
-    name.append(tmpName, tmpName + size);
-  } else if (err == UV_ENOBUFS) {
-    name.resize(size);
-    err = uv_os_gethostname(name.data(), &size);
-    if (err != 0) {
-      size = 0;
-    }
-  }
-
-  return {name.data(), size};
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/http_parser.cpp b/wpiutil/src/main/native/cpp/http_parser.cpp
deleted file mode 100644
index bc442b2..0000000
--- a/wpiutil/src/main/native/cpp/http_parser.cpp
+++ /dev/null
@@ -1,2475 +0,0 @@
-/* Copyright Joyent, Inc. and other Node 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.
- */
-#include "wpi/http_parser.h"
-#include <assert.h>
-#include <stddef.h>
-#include <ctype.h>
-#include <string.h>
-#include <limits.h>
-
-#ifdef _WIN32
-#pragma warning(disable : 4018 26451)
-#endif
-
-#ifndef ULLONG_MAX
-# define ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */
-#endif
-
-#ifndef MIN
-# define MIN(a,b) ((a) < (b) ? (a) : (b))
-#endif
-
-#ifndef ARRAY_SIZE
-# define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-#endif
-
-#ifndef BIT_AT
-# define BIT_AT(a, i)                                                \
-  (!!((unsigned int) (a)[(unsigned int) (i) >> 3] &                  \
-   (1 << ((unsigned int) (i) & 7))))
-#endif
-
-#ifndef ELEM_AT
-# define ELEM_AT(a, i, v) ((unsigned int) (i) < ARRAY_SIZE(a) ? (a)[(i)] : (v))
-#endif
-
-#define SET_ERRNO(e)                                                 \
-do {                                                                 \
-  parser->nread = nread;                                             \
-  parser->http_errno = (e);                                          \
-} while(0)
-
-#define CURRENT_STATE() p_state
-#define UPDATE_STATE(V) p_state = (enum state) (V);
-#define RETURN(V)                                                    \
-do {                                                                 \
-  parser->nread = nread;                                             \
-  parser->state = CURRENT_STATE();                                   \
-  return (V);                                                        \
-} while (0);
-#define REEXECUTE()                                                  \
-  goto reexecute;                                                    \
-
-
-#ifdef __GNUC__
-# define LIKELY(X) __builtin_expect(!!(X), 1)
-# define UNLIKELY(X) __builtin_expect(!!(X), 0)
-#else
-# define LIKELY(X) (X)
-# define UNLIKELY(X) (X)
-#endif
-
-
-/* Run the notify callback FOR, returning ER if it fails */
-#define CALLBACK_NOTIFY_(FOR, ER)                                    \
-do {                                                                 \
-  assert(HTTP_PARSER_ERRNO(parser) == HPE_OK);                       \
-                                                                     \
-  if (LIKELY(settings->on_##FOR)) {                                  \
-    parser->state = CURRENT_STATE();                                 \
-    if (UNLIKELY(0 != settings->on_##FOR(parser))) {                 \
-      SET_ERRNO(HPE_CB_##FOR);                                       \
-    }                                                                \
-    UPDATE_STATE(parser->state);                                     \
-                                                                     \
-    /* We either errored above or got paused; get out */             \
-    if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) {             \
-      return (ER);                                                   \
-    }                                                                \
-  }                                                                  \
-} while (0)
-
-/* Run the notify callback FOR and consume the current byte */
-#define CALLBACK_NOTIFY(FOR)            CALLBACK_NOTIFY_(FOR, p - data + 1)
-
-/* Run the notify callback FOR and don't consume the current byte */
-#define CALLBACK_NOTIFY_NOADVANCE(FOR)  CALLBACK_NOTIFY_(FOR, p - data)
-
-/* Run data callback FOR with LEN bytes, returning ER if it fails */
-#define CALLBACK_DATA_(FOR, LEN, ER)                                 \
-do {                                                                 \
-  assert(HTTP_PARSER_ERRNO(parser) == HPE_OK);                       \
-                                                                     \
-  if (FOR##_mark) {                                                  \
-    if (LIKELY(settings->on_##FOR)) {                                \
-      parser->state = CURRENT_STATE();                               \
-      if (UNLIKELY(0 !=                                              \
-                   settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \
-        SET_ERRNO(HPE_CB_##FOR);                                     \
-      }                                                              \
-      UPDATE_STATE(parser->state);                                   \
-                                                                     \
-      /* We either errored above or got paused; get out */           \
-      if (UNLIKELY(HTTP_PARSER_ERRNO(parser) != HPE_OK)) {           \
-        return (ER);                                                 \
-      }                                                              \
-    }                                                                \
-    FOR##_mark = NULL;                                               \
-  }                                                                  \
-} while (0)
-
-/* Run the data callback FOR and consume the current byte */
-#define CALLBACK_DATA(FOR)                                           \
-    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1)
-
-/* Run the data callback FOR and don't consume the current byte */
-#define CALLBACK_DATA_NOADVANCE(FOR)                                 \
-    CALLBACK_DATA_(FOR, p - FOR##_mark, p - data)
-
-/* Set the mark FOR; non-destructive if mark is already set */
-#define MARK(FOR)                                                    \
-do {                                                                 \
-  if (!FOR##_mark) {                                                 \
-    FOR##_mark = p;                                                  \
-  }                                                                  \
-} while (0)
-
-/* Don't allow the total size of the HTTP headers (including the status
- * line) to exceed HTTP_MAX_HEADER_SIZE.  This check is here to protect
- * embedders against denial-of-service attacks where the attacker feeds
- * us a never-ending header that the embedder keeps buffering.
- *
- * This check is arguably the responsibility of embedders but we're doing
- * it on the embedder's behalf because most won't bother and this way we
- * make the web a little safer.  HTTP_MAX_HEADER_SIZE is still far bigger
- * than any reasonable request or response so this should never affect
- * day-to-day operation.
- */
-#define COUNT_HEADER_SIZE(V)                                         \
-do {                                                                 \
-  nread += (V);                                                      \
-  if (UNLIKELY(nread > (HTTP_MAX_HEADER_SIZE))) {                    \
-    SET_ERRNO(HPE_HEADER_OVERFLOW);                                  \
-    goto error;                                                      \
-  }                                                                  \
-} while (0)
-
-
-#define PROXY_CONNECTION "proxy-connection"
-#define CONNECTION "connection"
-#define CONTENT_LENGTH "content-length"
-#define TRANSFER_ENCODING "transfer-encoding"
-#define UPGRADE "upgrade"
-#define CHUNKED "chunked"
-#define KEEP_ALIVE "keep-alive"
-#define CLOSE "close"
-
-namespace wpi {
-
-
-static const char *method_strings[] =
-  {
-#define XX(num, name, string) #string,
-  HTTP_METHOD_MAP(XX)
-#undef XX
-  };
-
-
-/* Tokens as defined by rfc 2616. Also lowercases them.
- *        token       = 1*<any CHAR except CTLs or separators>
- *     separators     = "(" | ")" | "<" | ">" | "@"
- *                    | "," | ";" | ":" | "\" | <">
- *                    | "/" | "[" | "]" | "?" | "="
- *                    | "{" | "}" | SP | HT
- */
-static const char tokens[256] = {
-/*   0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel  */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*   8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si   */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us  */
-        0,       0,       0,       0,       0,       0,       0,       0,
-/*  32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '  */
-       ' ',     '!',      0,      '#',     '$',     '%',     '&',    '\'',
-/*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        0,       0,      '*',     '+',      0,      '-',     '.',      0,
-/*  48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7  */
-       '0',     '1',     '2',     '3',     '4',     '5',     '6',     '7',
-/*  56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?  */
-       '8',     '9',      0,       0,       0,       0,       0,       0,
-/*  64  @    65  A    66  B    67  C    68  D    69  E    70  F    71  G  */
-        0,      'a',     'b',     'c',     'd',     'e',     'f',     'g',
-/*  72  H    73  I    74  J    75  K    76  L    77  M    78  N    79  O  */
-       'h',     'i',     'j',     'k',     'l',     'm',     'n',     'o',
-/*  80  P    81  Q    82  R    83  S    84  T    85  U    86  V    87  W  */
-       'p',     'q',     'r',     's',     't',     'u',     'v',     'w',
-/*  88  X    89  Y    90  Z    91  [    92  \    93  ]    94  ^    95  _  */
-       'x',     'y',     'z',      0,       0,       0,      '^',     '_',
-/*  96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g  */
-       '`',     'a',     'b',     'c',     'd',     'e',     'f',     'g',
-/* 104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o  */
-       'h',     'i',     'j',     'k',     'l',     'm',     'n',     'o',
-/* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
-       'p',     'q',     'r',     's',     't',     'u',     'v',     'w',
-/* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-       'x',     'y',     'z',      0,      '|',      0,      '~',       0 };
-
-
-static const int8_t unhex[256] =
-  {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
-  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
-  };
-
-
-#if HTTP_PARSER_STRICT
-# define T(v) 0
-#else
-# define T(v) v
-#endif
-
-
-static const uint8_t normal_url_char[32] = {
-/*   0 nul    1 soh    2 stx    3 etx    4 eot    5 enq    6 ack    7 bel  */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*   8 bs     9 ht    10 nl    11 vt    12 np    13 cr    14 so    15 si   */
-        0    | T(2)   |   0    |   0    | T(16)  |   0    |   0    |   0,
-/*  16 dle   17 dc1   18 dc2   19 dc3   20 dc4   21 nak   22 syn   23 etb */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*  24 can   25 em    26 sub   27 esc   28 fs    29 gs    30 rs    31 us  */
-        0    |   0    |   0    |   0    |   0    |   0    |   0    |   0,
-/*  32 sp    33  !    34  "    35  #    36  $    37  %    38  &    39  '  */
-        0    |   2    |   4    |   0    |   16   |   32   |   64   |  128,
-/*  40  (    41  )    42  *    43  +    44  ,    45  -    46  .    47  /  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  48  0    49  1    50  2    51  3    52  4    53  5    54  6    55  7  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  56  8    57  9    58  :    59  ;    60  <    61  =    62  >    63  ?  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |   0,
-/*  64  @    65  A    66  B    67  C    68  D    69  E    70  F    71  G  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  72  H    73  I    74  J    75  K    76  L    77  M    78  N    79  O  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  80  P    81  Q    82  R    83  S    84  T    85  U    86  V    87  W  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  88  X    89  Y    90  Z    91  [    92  \    93  ]    94  ^    95  _  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/*  96  `    97  a    98  b    99  c   100  d   101  e   102  f   103  g  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 104  h   105  i   106  j   107  k   108  l   109  m   110  n   111  o  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 112  p   113  q   114  r   115  s   116  t   117  u   118  v   119  w  */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |  128,
-/* 120  x   121  y   122  z   123  {   124  |   125  }   126  ~   127 del */
-        1    |   2    |   4    |   8    |   16   |   32   |   64   |   0, };
-
-#undef T
-
-enum state
-  { s_dead = 1 /* important that this is > 0 */
-
-  , s_start_req_or_res
-  , s_res_or_resp_H
-  , s_start_res
-  , s_res_H
-  , s_res_HT
-  , s_res_HTT
-  , s_res_HTTP
-  , s_res_http_major
-  , s_res_http_dot
-  , s_res_http_minor
-  , s_res_http_end
-  , s_res_first_status_code
-  , s_res_status_code
-  , s_res_status_start
-  , s_res_status
-  , s_res_line_almost_done
-
-  , s_start_req
-
-  , s_req_method
-  , s_req_spaces_before_url
-  , s_req_schema
-  , s_req_schema_slash
-  , s_req_schema_slash_slash
-  , s_req_server_start
-  , s_req_server
-  , s_req_server_with_at
-  , s_req_path
-  , s_req_query_string_start
-  , s_req_query_string
-  , s_req_fragment_start
-  , s_req_fragment
-  , s_req_http_start
-  , s_req_http_H
-  , s_req_http_HT
-  , s_req_http_HTT
-  , s_req_http_HTTP
-  , s_req_http_major
-  , s_req_http_dot
-  , s_req_http_minor
-  , s_req_http_end
-  , s_req_line_almost_done
-
-  , s_header_field_start
-  , s_header_field
-  , s_header_value_discard_ws
-  , s_header_value_discard_ws_almost_done
-  , s_header_value_discard_lws
-  , s_header_value_start
-  , s_header_value
-  , s_header_value_lws
-
-  , s_header_almost_done
-
-  , s_chunk_size_start
-  , s_chunk_size
-  , s_chunk_parameters
-  , s_chunk_size_almost_done
-
-  , s_headers_almost_done
-  , s_headers_done
-
-  /* Important: 's_headers_done' must be the last 'header' state. All
-   * states beyond this must be 'body' states. It is used for overflow
-   * checking. See the PARSING_HEADER() macro.
-   */
-
-  , s_chunk_data
-  , s_chunk_data_almost_done
-  , s_chunk_data_done
-
-  , s_body_identity
-  , s_body_identity_eof
-
-  , s_message_done
-  };
-
-
-#define PARSING_HEADER(state) (state <= s_headers_done)
-
-
-enum header_states
-  { h_general = 0
-  , h_C
-  , h_CO
-  , h_CON
-
-  , h_matching_connection
-  , h_matching_proxy_connection
-  , h_matching_content_length
-  , h_matching_transfer_encoding
-  , h_matching_upgrade
-
-  , h_connection
-  , h_content_length
-  , h_content_length_num
-  , h_content_length_ws
-  , h_transfer_encoding
-  , h_upgrade
-
-  , h_matching_transfer_encoding_chunked
-  , h_matching_connection_token_start
-  , h_matching_connection_keep_alive
-  , h_matching_connection_close
-  , h_matching_connection_upgrade
-  , h_matching_connection_token
-
-  , h_transfer_encoding_chunked
-  , h_connection_keep_alive
-  , h_connection_close
-  , h_connection_upgrade
-  };
-
-enum http_host_state
-  {
-    s_http_host_dead = 1
-  , s_http_userinfo_start
-  , s_http_userinfo
-  , s_http_host_start
-  , s_http_host_v6_start
-  , s_http_host
-  , s_http_host_v6
-  , s_http_host_v6_end
-  , s_http_host_v6_zone_start
-  , s_http_host_v6_zone
-  , s_http_host_port_start
-  , s_http_host_port
-};
-
-/* Macros for character classes; depends on strict-mode  */
-#define CR                  '\r'
-#define LF                  '\n'
-#define LOWER(c)            (unsigned char)(c | 0x20)
-#define IS_ALPHA(c)         (LOWER(c) >= 'a' && LOWER(c) <= 'z')
-#define IS_NUM(c)           ((c) >= '0' && (c) <= '9')
-#define IS_ALPHANUM(c)      (IS_ALPHA(c) || IS_NUM(c))
-#define IS_HEX(c)           (IS_NUM(c) || (LOWER(c) >= 'a' && LOWER(c) <= 'f'))
-#define IS_MARK(c)          ((c) == '-' || (c) == '_' || (c) == '.' || \
-  (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \
-  (c) == ')')
-#define IS_USERINFO_CHAR(c) (IS_ALPHANUM(c) || IS_MARK(c) || (c) == '%' || \
-  (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \
-  (c) == '$' || (c) == ',')
-
-#define STRICT_TOKEN(c)     ((c == ' ') ? 0 : tokens[(unsigned char)c])
-
-#if HTTP_PARSER_STRICT
-#define TOKEN(c)            STRICT_TOKEN(c)
-#define IS_URL_CHAR(c)      (BIT_AT(normal_url_char, (unsigned char)c))
-#define IS_HOST_CHAR(c)     (IS_ALPHANUM(c) || (c) == '.' || (c) == '-')
-#else
-#define TOKEN(c)            tokens[(unsigned char)c]
-#define IS_URL_CHAR(c)                                                         \
-  (BIT_AT(normal_url_char, (unsigned char)c) || ((c) & 0x80))
-#define IS_HOST_CHAR(c)                                                        \
-  (IS_ALPHANUM(c) || (c) == '.' || (c) == '-' || (c) == '_')
-#endif
-
-/**
- * Verify that a char is a valid visible (printable) US-ASCII
- * character or %x80-FF
- **/
-#define IS_HEADER_CHAR(ch)                                                     \
-  (ch == CR || ch == LF || ch == 9 || ((unsigned char)ch > 31 && ch != 127))
-
-#define start_state (parser->type == HTTP_REQUEST ? s_start_req : s_start_res)
-
-
-#if HTTP_PARSER_STRICT
-# define STRICT_CHECK(cond)                                          \
-do {                                                                 \
-  if (cond) {                                                        \
-    SET_ERRNO(HPE_STRICT);                                           \
-    goto error;                                                      \
-  }                                                                  \
-} while (0)
-# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
-#else
-# define STRICT_CHECK(cond)
-# define NEW_MESSAGE() start_state
-#endif
-
-
-/* Map errno values to strings for human-readable output */
-#define HTTP_STRERROR_GEN(n, s) { "HPE_" #n, s },
-static struct {
-  const char *name;
-  const char *description;
-} http_strerror_tab[] = {
-  HTTP_ERRNO_MAP(HTTP_STRERROR_GEN)
-};
-#undef HTTP_STRERROR_GEN
-
-int http_message_needs_eof(const http_parser *parser);
-
-/* Our URL parser.
- *
- * This is designed to be shared by http_parser_execute() for URL validation,
- * hence it has a state transition + byte-for-byte interface. In addition, it
- * is meant to be embedded in http_parser_parse_url(), which does the dirty
- * work of turning state transitions URL components for its API.
- *
- * This function should only be invoked with non-space characters. It is
- * assumed that the caller cares about (and can detect) the transition between
- * URL and non-URL states by looking for these.
- */
-static enum state
-parse_url_char(enum state s, const char ch)
-{
-  if (ch == ' ' || ch == '\r' || ch == '\n') {
-    return s_dead;
-  }
-
-#if HTTP_PARSER_STRICT
-  if (ch == '\t' || ch == '\f') {
-    return s_dead;
-  }
-#endif
-
-  switch (s) {
-    case s_req_spaces_before_url:
-      /* Proxied requests are followed by scheme of an absolute URI (alpha).
-       * All methods except CONNECT are followed by '/' or '*'.
-       */
-
-      if (ch == '/' || ch == '*') {
-        return s_req_path;
-      }
-
-      if (IS_ALPHA(ch)) {
-        return s_req_schema;
-      }
-
-      break;
-
-    case s_req_schema:
-      if (IS_ALPHA(ch)) {
-        return s;
-      }
-
-      if (ch == ':') {
-        return s_req_schema_slash;
-      }
-
-      break;
-
-    case s_req_schema_slash:
-      if (ch == '/') {
-        return s_req_schema_slash_slash;
-      }
-
-      break;
-
-    case s_req_schema_slash_slash:
-      if (ch == '/') {
-        return s_req_server_start;
-      }
-
-      break;
-
-    case s_req_server_with_at:
-      if (ch == '@') {
-        return s_dead;
-      }
-
-    /* fall through */
-    case s_req_server_start:
-    case s_req_server:
-      if (ch == '/') {
-        return s_req_path;
-      }
-
-      if (ch == '?') {
-        return s_req_query_string_start;
-      }
-
-      if (ch == '@') {
-        return s_req_server_with_at;
-      }
-
-      if (IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') {
-        return s_req_server;
-      }
-
-      break;
-
-    case s_req_path:
-      if (IS_URL_CHAR(ch)) {
-        return s;
-      }
-
-      switch (ch) {
-        case '?':
-          return s_req_query_string_start;
-
-        case '#':
-          return s_req_fragment_start;
-      }
-
-      break;
-
-    case s_req_query_string_start:
-    case s_req_query_string:
-      if (IS_URL_CHAR(ch)) {
-        return s_req_query_string;
-      }
-
-      switch (ch) {
-        case '?':
-          /* allow extra '?' in query string */
-          return s_req_query_string;
-
-        case '#':
-          return s_req_fragment_start;
-      }
-
-      break;
-
-    case s_req_fragment_start:
-      if (IS_URL_CHAR(ch)) {
-        return s_req_fragment;
-      }
-
-      switch (ch) {
-        case '?':
-          return s_req_fragment;
-
-        case '#':
-          return s;
-      }
-
-      break;
-
-    case s_req_fragment:
-      if (IS_URL_CHAR(ch)) {
-        return s;
-      }
-
-      switch (ch) {
-        case '?':
-        case '#':
-          return s;
-      }
-
-      break;
-
-    default:
-      break;
-  }
-
-  /* We should never fall out of the switch above unless there's an error */
-  return s_dead;
-}
-
-size_t http_parser_execute (http_parser *parser,
-                            const http_parser_settings *settings,
-                            const char *data,
-                            size_t len)
-{
-  char c, ch;
-  int8_t unhex_val;
-  const char *p = data;
-  const char *header_field_mark = 0;
-  const char *header_value_mark = 0;
-  const char *url_mark = 0;
-  const char *body_mark = 0;
-  const char *status_mark = 0;
-  enum state p_state = (enum state) parser->state;
-  const unsigned int lenient = parser->lenient_http_headers;
-  uint32_t nread = parser->nread;
-
-  /* We're in an error state. Don't bother doing anything. */
-  if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
-    return 0;
-  }
-
-  if (len == 0) {
-    switch (CURRENT_STATE()) {
-      case s_body_identity_eof:
-        /* Use of CALLBACK_NOTIFY() here would erroneously return 1 byte read if
-         * we got paused.
-         */
-        CALLBACK_NOTIFY_NOADVANCE(message_complete);
-        return 0;
-
-      case s_dead:
-      case s_start_req_or_res:
-      case s_start_res:
-      case s_start_req:
-        return 0;
-
-      default:
-        SET_ERRNO(HPE_INVALID_EOF_STATE);
-        return 1;
-    }
-  }
-
-
-  if (CURRENT_STATE() == s_header_field)
-    header_field_mark = data;
-  if (CURRENT_STATE() == s_header_value)
-    header_value_mark = data;
-  switch (CURRENT_STATE()) {
-  case s_req_path:
-  case s_req_schema:
-  case s_req_schema_slash:
-  case s_req_schema_slash_slash:
-  case s_req_server_start:
-  case s_req_server:
-  case s_req_server_with_at:
-  case s_req_query_string_start:
-  case s_req_query_string:
-  case s_req_fragment_start:
-  case s_req_fragment:
-    url_mark = data;
-    break;
-  case s_res_status:
-    status_mark = data;
-    break;
-  default:
-    break;
-  }
-
-  for (p=data; p != data + len; p++) {
-    ch = *p;
-
-    if (PARSING_HEADER(CURRENT_STATE()))
-      COUNT_HEADER_SIZE(1);
-
-reexecute:
-    switch (CURRENT_STATE()) {
-
-      case s_dead:
-        /* this state is used after a 'Connection: close' message
-         * the parser will error out if it reads another message
-         */
-        if (LIKELY(ch == CR || ch == LF))
-          break;
-
-        SET_ERRNO(HPE_CLOSED_CONNECTION);
-        goto error;
-
-      case s_start_req_or_res:
-      {
-        if (ch == CR || ch == LF)
-          break;
-        parser->flags = 0;
-        parser->content_length = ULLONG_MAX;
-
-        if (ch == 'H') {
-          UPDATE_STATE(s_res_or_resp_H);
-
-          CALLBACK_NOTIFY(message_begin);
-        } else {
-          parser->type = HTTP_REQUEST;
-          UPDATE_STATE(s_start_req);
-          REEXECUTE();
-        }
-
-        break;
-      }
-
-      case s_res_or_resp_H:
-        if (ch == 'T') {
-          parser->type = HTTP_RESPONSE;
-          UPDATE_STATE(s_res_HT);
-        } else {
-          if (UNLIKELY(ch != 'E')) {
-            SET_ERRNO(HPE_INVALID_CONSTANT);
-            goto error;
-          }
-
-          parser->type = HTTP_REQUEST;
-          parser->method = HTTP_HEAD;
-          parser->index = 2;
-          UPDATE_STATE(s_req_method);
-        }
-        break;
-
-      case s_start_res:
-      {
-        parser->flags = 0;
-        parser->content_length = ULLONG_MAX;
-
-        switch (ch) {
-          case 'H':
-            UPDATE_STATE(s_res_H);
-            break;
-
-          case CR:
-          case LF:
-            break;
-
-          default:
-            SET_ERRNO(HPE_INVALID_CONSTANT);
-            goto error;
-        }
-
-        CALLBACK_NOTIFY(message_begin);
-        break;
-      }
-
-      case s_res_H:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_res_HT);
-        break;
-
-      case s_res_HT:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_res_HTT);
-        break;
-
-      case s_res_HTT:
-        STRICT_CHECK(ch != 'P');
-        UPDATE_STATE(s_res_HTTP);
-        break;
-
-      case s_res_HTTP:
-        STRICT_CHECK(ch != '/');
-        UPDATE_STATE(s_res_http_major);
-        break;
-
-      case s_res_http_major:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_major = ch - '0';
-        UPDATE_STATE(s_res_http_dot);
-        break;
-
-      case s_res_http_dot:
-      {
-        if (UNLIKELY(ch != '.')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_res_http_minor);
-        break;
-      }
-
-      case s_res_http_minor:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_minor = ch - '0';
-        UPDATE_STATE(s_res_http_end);
-        break;
-
-      case s_res_http_end:
-      {
-        if (UNLIKELY(ch != ' ')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_res_first_status_code);
-        break;
-      }
-
-      case s_res_first_status_code:
-      {
-        if (!IS_NUM(ch)) {
-          if (ch == ' ') {
-            break;
-          }
-
-          SET_ERRNO(HPE_INVALID_STATUS);
-          goto error;
-        }
-        parser->status_code = ch - '0';
-        UPDATE_STATE(s_res_status_code);
-        break;
-      }
-
-      case s_res_status_code:
-      {
-        if (!IS_NUM(ch)) {
-          switch (ch) {
-            case ' ':
-              UPDATE_STATE(s_res_status_start);
-              break;
-            case CR:
-            case LF:
-              UPDATE_STATE(s_res_status_start);
-              REEXECUTE();
-              break;
-            default:
-              SET_ERRNO(HPE_INVALID_STATUS);
-              goto error;
-          }
-          break;
-        }
-
-        parser->status_code *= 10;
-        parser->status_code += ch - '0';
-
-        if (UNLIKELY(parser->status_code > 999)) {
-          SET_ERRNO(HPE_INVALID_STATUS);
-          goto error;
-        }
-
-        break;
-      }
-
-      case s_res_status_start:
-      {
-        MARK(status);
-        UPDATE_STATE(s_res_status);
-        parser->index = 0;
-
-        if (ch == CR || ch == LF)
-          REEXECUTE();
-
-        break;
-      }
-
-      case s_res_status:
-        if (ch == CR) {
-          UPDATE_STATE(s_res_line_almost_done);
-          CALLBACK_DATA(status);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_field_start);
-          CALLBACK_DATA(status);
-          break;
-        }
-
-        break;
-
-      case s_res_line_almost_done:
-        STRICT_CHECK(ch != LF);
-        UPDATE_STATE(s_header_field_start);
-        break;
-
-      case s_start_req:
-      {
-        if (ch == CR || ch == LF)
-          break;
-        parser->flags = 0;
-        parser->content_length = ULLONG_MAX;
-
-        if (UNLIKELY(!IS_ALPHA(ch))) {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        parser->method = (enum http_method) 0;
-        parser->index = 1;
-        switch (ch) {
-          case 'A': parser->method = HTTP_ACL; break;
-          case 'B': parser->method = HTTP_BIND; break;
-          case 'C': parser->method = HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
-          case 'D': parser->method = HTTP_DELETE; break;
-          case 'G': parser->method = HTTP_GET; break;
-          case 'H': parser->method = HTTP_HEAD; break;
-          case 'L': parser->method = HTTP_LOCK; /* or LINK */ break;
-          case 'M': parser->method = HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break;
-          case 'N': parser->method = HTTP_NOTIFY; break;
-          case 'O': parser->method = HTTP_OPTIONS; break;
-          case 'P': parser->method = HTTP_POST;
-            /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */
-            break;
-          case 'R': parser->method = HTTP_REPORT; /* or REBIND */ break;
-          case 'S': parser->method = HTTP_SUBSCRIBE; /* or SEARCH, SOURCE */ break;
-          case 'T': parser->method = HTTP_TRACE; break;
-          case 'U': parser->method = HTTP_UNLOCK; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break;
-          default:
-            SET_ERRNO(HPE_INVALID_METHOD);
-            goto error;
-        }
-        UPDATE_STATE(s_req_method);
-
-        CALLBACK_NOTIFY(message_begin);
-
-        break;
-      }
-
-      case s_req_method:
-      {
-        const char *matcher;
-        if (UNLIKELY(ch == '\0')) {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        matcher = method_strings[parser->method];
-        if (ch == ' ' && matcher[parser->index] == '\0') {
-          UPDATE_STATE(s_req_spaces_before_url);
-        } else if (ch == matcher[parser->index]) {
-          ; /* nada */
-        } else if ((ch >= 'A' && ch <= 'Z') || ch == '-') {
-
-          switch (parser->method << 16 | parser->index << 8 | ch) {
-#define XX(meth, pos, ch, new_meth) \
-            case (HTTP_##meth << 16 | pos << 8 | ch): \
-              parser->method = HTTP_##new_meth; break;
-
-            XX(POST,      1, 'U', PUT)
-            XX(POST,      1, 'A', PATCH)
-            XX(POST,      1, 'R', PROPFIND)
-            XX(PUT,       2, 'R', PURGE)
-            XX(CONNECT,   1, 'H', CHECKOUT)
-            XX(CONNECT,   2, 'P', COPY)
-            XX(MKCOL,     1, 'O', MOVE)
-            XX(MKCOL,     1, 'E', MERGE)
-            XX(MKCOL,     1, '-', MSEARCH)
-            XX(MKCOL,     2, 'A', MKACTIVITY)
-            XX(MKCOL,     3, 'A', MKCALENDAR)
-            XX(SUBSCRIBE, 1, 'E', SEARCH)
-            XX(SUBSCRIBE, 1, 'O', SOURCE)
-            XX(REPORT,    2, 'B', REBIND)
-            XX(PROPFIND,  4, 'P', PROPPATCH)
-            XX(LOCK,      1, 'I', LINK)
-            XX(UNLOCK,    2, 'S', UNSUBSCRIBE)
-            XX(UNLOCK,    2, 'B', UNBIND)
-            XX(UNLOCK,    3, 'I', UNLINK)
-#undef XX
-            default:
-              SET_ERRNO(HPE_INVALID_METHOD);
-              goto error;
-          }
-        } else {
-          SET_ERRNO(HPE_INVALID_METHOD);
-          goto error;
-        }
-
-        ++parser->index;
-        break;
-      }
-
-      case s_req_spaces_before_url:
-      {
-        if (ch == ' ') break;
-
-        MARK(url);
-        if (parser->method == HTTP_CONNECT) {
-          UPDATE_STATE(s_req_server_start);
-        }
-
-        UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-        if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-          SET_ERRNO(HPE_INVALID_URL);
-          goto error;
-        }
-
-        break;
-      }
-
-      case s_req_schema:
-      case s_req_schema_slash:
-      case s_req_schema_slash_slash:
-      case s_req_server_start:
-      {
-        switch (ch) {
-          /* No whitespace allowed here */
-          case ' ':
-          case CR:
-          case LF:
-            SET_ERRNO(HPE_INVALID_URL);
-            goto error;
-          default:
-            UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-            if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-              SET_ERRNO(HPE_INVALID_URL);
-              goto error;
-            }
-        }
-
-        break;
-      }
-
-      case s_req_server:
-      case s_req_server_with_at:
-      case s_req_path:
-      case s_req_query_string_start:
-      case s_req_query_string:
-      case s_req_fragment_start:
-      case s_req_fragment:
-      {
-        switch (ch) {
-          case ' ':
-            UPDATE_STATE(s_req_http_start);
-            CALLBACK_DATA(url);
-            break;
-          case CR:
-          case LF:
-            parser->http_major = 0;
-            parser->http_minor = 9;
-            UPDATE_STATE((ch == CR) ?
-              s_req_line_almost_done :
-              s_header_field_start);
-            CALLBACK_DATA(url);
-            break;
-          default:
-            UPDATE_STATE(parse_url_char(CURRENT_STATE(), ch));
-            if (UNLIKELY(CURRENT_STATE() == s_dead)) {
-              SET_ERRNO(HPE_INVALID_URL);
-              goto error;
-            }
-        }
-        break;
-      }
-
-      case s_req_http_start:
-        switch (ch) {
-          case 'H':
-            UPDATE_STATE(s_req_http_H);
-            break;
-          case ' ':
-            break;
-          default:
-            SET_ERRNO(HPE_INVALID_CONSTANT);
-            goto error;
-        }
-        break;
-
-      case s_req_http_H:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_req_http_HT);
-        break;
-
-      case s_req_http_HT:
-        STRICT_CHECK(ch != 'T');
-        UPDATE_STATE(s_req_http_HTT);
-        break;
-
-      case s_req_http_HTT:
-        STRICT_CHECK(ch != 'P');
-        UPDATE_STATE(s_req_http_HTTP);
-        break;
-
-      case s_req_http_HTTP:
-        STRICT_CHECK(ch != '/');
-        UPDATE_STATE(s_req_http_major);
-        break;
-
-      case s_req_http_major:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_major = ch - '0';
-        UPDATE_STATE(s_req_http_dot);
-        break;
-
-      case s_req_http_dot:
-      {
-        if (UNLIKELY(ch != '.')) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        UPDATE_STATE(s_req_http_minor);
-        break;
-      }
-
-      case s_req_http_minor:
-        if (UNLIKELY(!IS_NUM(ch))) {
-          SET_ERRNO(HPE_INVALID_VERSION);
-          goto error;
-        }
-
-        parser->http_minor = ch - '0';
-        UPDATE_STATE(s_req_http_end);
-        break;
-
-      case s_req_http_end:
-      {
-        if (ch == CR) {
-          UPDATE_STATE(s_req_line_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_field_start);
-          break;
-        }
-
-        SET_ERRNO(HPE_INVALID_VERSION);
-        goto error;
-        break;
-      }
-
-      /* end of request line */
-      case s_req_line_almost_done:
-      {
-        if (UNLIKELY(ch != LF)) {
-          SET_ERRNO(HPE_LF_EXPECTED);
-          goto error;
-        }
-
-        UPDATE_STATE(s_header_field_start);
-        break;
-      }
-
-      case s_header_field_start:
-      {
-        if (ch == CR) {
-          UPDATE_STATE(s_headers_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          /* they might be just sending \n instead of \r\n so this would be
-           * the second \n to denote the end of headers*/
-          UPDATE_STATE(s_headers_almost_done);
-          REEXECUTE();
-        }
-
-        c = TOKEN(ch);
-
-        if (UNLIKELY(!c)) {
-          SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-          goto error;
-        }
-
-        MARK(header_field);
-
-        parser->index = 0;
-        UPDATE_STATE(s_header_field);
-
-        switch (c) {
-          case 'c':
-            parser->header_state = h_C;
-            break;
-
-          case 'p':
-            parser->header_state = h_matching_proxy_connection;
-            break;
-
-          case 't':
-            parser->header_state = h_matching_transfer_encoding;
-            break;
-
-          case 'u':
-            parser->header_state = h_matching_upgrade;
-            break;
-
-          default:
-            parser->header_state = h_general;
-            break;
-        }
-        break;
-      }
-
-      case s_header_field:
-      {
-        const char* start = p;
-        for (; p != data + len; p++) {
-          ch = *p;
-          c = TOKEN(ch);
-
-          if (!c)
-            break;
-
-          switch (parser->header_state) {
-            case h_general: {
-              size_t limit = data + len - p;
-              limit = MIN(limit, HTTP_MAX_HEADER_SIZE);
-              while (p+1 < data + limit && TOKEN(p[1])) {
-                p++;
-              }
-              break;
-            }
-
-            case h_C:
-              parser->index++;
-              parser->header_state = (c == 'o' ? h_CO : h_general);
-              break;
-
-            case h_CO:
-              parser->index++;
-              parser->header_state = (c == 'n' ? h_CON : h_general);
-              break;
-
-            case h_CON:
-              parser->index++;
-              switch (c) {
-                case 'n':
-                  parser->header_state = h_matching_connection;
-                  break;
-                case 't':
-                  parser->header_state = h_matching_content_length;
-                  break;
-                default:
-                  parser->header_state = h_general;
-                  break;
-              }
-              break;
-
-            /* connection */
-
-            case h_matching_connection:
-              parser->index++;
-              if (parser->index > sizeof(CONNECTION)-1
-                  || c != CONNECTION[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(CONNECTION)-2) {
-                parser->header_state = h_connection;
-              }
-              break;
-
-            /* proxy-connection */
-
-            case h_matching_proxy_connection:
-              parser->index++;
-              if (parser->index > sizeof(PROXY_CONNECTION)-1
-                  || c != PROXY_CONNECTION[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(PROXY_CONNECTION)-2) {
-                parser->header_state = h_connection;
-              }
-              break;
-
-            /* content-length */
-
-            case h_matching_content_length:
-              parser->index++;
-              if (parser->index > sizeof(CONTENT_LENGTH)-1
-                  || c != CONTENT_LENGTH[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(CONTENT_LENGTH)-2) {
-                parser->header_state = h_content_length;
-              }
-              break;
-
-            /* transfer-encoding */
-
-            case h_matching_transfer_encoding:
-              parser->index++;
-              if (parser->index > sizeof(TRANSFER_ENCODING)-1
-                  || c != TRANSFER_ENCODING[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) {
-                parser->header_state = h_transfer_encoding;
-              }
-              break;
-
-            /* upgrade */
-
-            case h_matching_upgrade:
-              parser->index++;
-              if (parser->index > sizeof(UPGRADE)-1
-                  || c != UPGRADE[parser->index]) {
-                parser->header_state = h_general;
-              } else if (parser->index == sizeof(UPGRADE)-2) {
-                parser->header_state = h_upgrade;
-              }
-              break;
-
-            case h_connection:
-            case h_content_length:
-            case h_transfer_encoding:
-            case h_upgrade:
-              if (ch != ' ') parser->header_state = h_general;
-              break;
-
-            default:
-              assert(0 && "Unknown header_state");
-              break;
-          }
-        }
-
-        if (p == data + len) {
-          --p;
-          COUNT_HEADER_SIZE(p - start);
-          break;
-        }
-
-        COUNT_HEADER_SIZE(p - start);
-
-        if (ch == ':') {
-          UPDATE_STATE(s_header_value_discard_ws);
-          CALLBACK_DATA(header_field);
-          break;
-        }
-
-        SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-        goto error;
-      }
-
-      case s_header_value_discard_ws:
-        if (ch == ' ' || ch == '\t') break;
-
-        if (ch == CR) {
-          UPDATE_STATE(s_header_value_discard_ws_almost_done);
-          break;
-        }
-
-        if (ch == LF) {
-          UPDATE_STATE(s_header_value_discard_lws);
-          break;
-        }
-
-        /* fall through */
-
-      case s_header_value_start:
-      {
-        MARK(header_value);
-
-        UPDATE_STATE(s_header_value);
-        parser->index = 0;
-
-        c = LOWER(ch);
-
-        switch (parser->header_state) {
-          case h_upgrade:
-            parser->flags |= F_UPGRADE;
-            parser->header_state = h_general;
-            break;
-
-          case h_transfer_encoding:
-            /* looking for 'Transfer-Encoding: chunked' */
-            if ('c' == c) {
-              parser->header_state = h_matching_transfer_encoding_chunked;
-            } else {
-              parser->header_state = h_general;
-            }
-            break;
-
-          case h_content_length:
-            if (UNLIKELY(!IS_NUM(ch))) {
-              SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-              goto error;
-            }
-
-            if (parser->flags & F_CONTENTLENGTH) {
-              SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
-              goto error;
-            }
-
-            parser->flags |= F_CONTENTLENGTH;
-            parser->content_length = ch - '0';
-            parser->header_state = h_content_length_num;
-            break;
-
-          case h_connection:
-            /* looking for 'Connection: keep-alive' */
-            if (c == 'k') {
-              parser->header_state = h_matching_connection_keep_alive;
-            /* looking for 'Connection: close' */
-            } else if (c == 'c') {
-              parser->header_state = h_matching_connection_close;
-            } else if (c == 'u') {
-              parser->header_state = h_matching_connection_upgrade;
-            } else {
-              parser->header_state = h_matching_connection_token;
-            }
-            break;
-
-          /* Multi-value `Connection` header */
-          case h_matching_connection_token_start:
-            break;
-
-          default:
-            parser->header_state = h_general;
-            break;
-        }
-        break;
-      }
-
-      case s_header_value:
-      {
-        const char* start = p;
-        enum header_states h_state = (enum header_states) parser->header_state;
-        for (; p != data + len; p++) {
-          ch = *p;
-          if (ch == CR) {
-            UPDATE_STATE(s_header_almost_done);
-            parser->header_state = h_state;
-            CALLBACK_DATA(header_value);
-            break;
-          }
-
-          if (ch == LF) {
-            UPDATE_STATE(s_header_almost_done);
-            COUNT_HEADER_SIZE(p - start);
-            parser->header_state = h_state;
-            CALLBACK_DATA_NOADVANCE(header_value);
-            REEXECUTE();
-          }
-
-          if (!lenient && !IS_HEADER_CHAR(ch)) {
-            SET_ERRNO(HPE_INVALID_HEADER_TOKEN);
-            goto error;
-          }
-
-          c = LOWER(ch);
-
-          switch (h_state) {
-            case h_general:
-            {
-              const char* p_cr;
-              const char* p_lf;
-              size_t limit = data + len - p;
-
-              limit = MIN(limit, HTTP_MAX_HEADER_SIZE);
-
-              p_cr = (const char*) memchr(p, CR, limit);
-              p_lf = (const char*) memchr(p, LF, limit);
-              if (p_cr != NULL) {
-                if (p_lf != NULL && p_cr >= p_lf)
-                  p = p_lf;
-                else
-                  p = p_cr;
-              } else if (UNLIKELY(p_lf != NULL)) {
-                p = p_lf;
-              } else {
-                p = data + len;
-              }
-              --p;
-              break;
-            }
-
-            case h_connection:
-            case h_transfer_encoding:
-              assert(0 && "Shouldn't get here.");
-              break;
-
-            case h_content_length:
-              if (ch == ' ') break;
-              h_state = h_content_length_num;
-              /* fall through */
-
-            case h_content_length_num:
-            {
-              uint64_t t;
-
-              if (ch == ' ') {
-                h_state = h_content_length_ws;
-                break;
-              }
-
-              if (UNLIKELY(!IS_NUM(ch))) {
-                SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-                parser->header_state = h_state;
-                goto error;
-              }
-
-              t = parser->content_length;
-              t *= 10;
-              t += ch - '0';
-
-              /* Overflow? Test against a conservative limit for simplicity. */
-              if (UNLIKELY((ULLONG_MAX - 10) / 10 < parser->content_length)) {
-                SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-                parser->header_state = h_state;
-                goto error;
-              }
-
-              parser->content_length = t;
-              break;
-            }
-
-            case h_content_length_ws:
-              if (ch == ' ') break;
-              SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-              parser->header_state = h_state;
-              goto error;
-
-            /* Transfer-Encoding: chunked */
-            case h_matching_transfer_encoding_chunked:
-              parser->index++;
-              if (parser->index > sizeof(CHUNKED)-1
-                  || c != CHUNKED[parser->index]) {
-                h_state = h_general;
-              } else if (parser->index == sizeof(CHUNKED)-2) {
-                h_state = h_transfer_encoding_chunked;
-              }
-              break;
-
-            case h_matching_connection_token_start:
-              /* looking for 'Connection: keep-alive' */
-              if (c == 'k') {
-                h_state = h_matching_connection_keep_alive;
-              /* looking for 'Connection: close' */
-              } else if (c == 'c') {
-                h_state = h_matching_connection_close;
-              } else if (c == 'u') {
-                h_state = h_matching_connection_upgrade;
-              } else if (STRICT_TOKEN(c)) {
-                h_state = h_matching_connection_token;
-              } else if (c == ' ' || c == '\t') {
-                /* Skip lws */
-              } else {
-                h_state = h_general;
-              }
-              break;
-
-            /* looking for 'Connection: keep-alive' */
-            case h_matching_connection_keep_alive:
-              parser->index++;
-              if (parser->index > sizeof(KEEP_ALIVE)-1
-                  || c != KEEP_ALIVE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(KEEP_ALIVE)-2) {
-                h_state = h_connection_keep_alive;
-              }
-              break;
-
-            /* looking for 'Connection: close' */
-            case h_matching_connection_close:
-              parser->index++;
-              if (parser->index > sizeof(CLOSE)-1 || c != CLOSE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(CLOSE)-2) {
-                h_state = h_connection_close;
-              }
-              break;
-
-            /* looking for 'Connection: upgrade' */
-            case h_matching_connection_upgrade:
-              parser->index++;
-              if (parser->index > sizeof(UPGRADE) - 1 ||
-                  c != UPGRADE[parser->index]) {
-                h_state = h_matching_connection_token;
-              } else if (parser->index == sizeof(UPGRADE)-2) {
-                h_state = h_connection_upgrade;
-              }
-              break;
-
-            case h_matching_connection_token:
-              if (ch == ',') {
-                h_state = h_matching_connection_token_start;
-                parser->index = 0;
-              }
-              break;
-
-            case h_transfer_encoding_chunked:
-              if (ch != ' ') h_state = h_general;
-              break;
-
-            case h_connection_keep_alive:
-            case h_connection_close:
-            case h_connection_upgrade:
-              if (ch == ',') {
-                if (h_state == h_connection_keep_alive) {
-                  parser->flags |= F_CONNECTION_KEEP_ALIVE;
-                } else if (h_state == h_connection_close) {
-                  parser->flags |= F_CONNECTION_CLOSE;
-                } else if (h_state == h_connection_upgrade) {
-                  parser->flags |= F_CONNECTION_UPGRADE;
-                }
-                h_state = h_matching_connection_token_start;
-                parser->index = 0;
-              } else if (ch != ' ') {
-                h_state = h_matching_connection_token;
-              }
-              break;
-
-            default:
-              UPDATE_STATE(s_header_value);
-              h_state = h_general;
-              break;
-          }
-        }
-        parser->header_state = h_state;
-
-        if (p == data + len)
-          --p;
-
-        COUNT_HEADER_SIZE(p - start);
-        break;
-      }
-
-      case s_header_almost_done:
-      {
-        if (UNLIKELY(ch != LF)) {
-          SET_ERRNO(HPE_LF_EXPECTED);
-          goto error;
-        }
-
-        UPDATE_STATE(s_header_value_lws);
-        break;
-      }
-
-      case s_header_value_lws:
-      {
-        if (ch == ' ' || ch == '\t') {
-          UPDATE_STATE(s_header_value_start);
-          REEXECUTE();
-        }
-
-        /* finished the header */
-        switch (parser->header_state) {
-          case h_connection_keep_alive:
-            parser->flags |= F_CONNECTION_KEEP_ALIVE;
-            break;
-          case h_connection_close:
-            parser->flags |= F_CONNECTION_CLOSE;
-            break;
-          case h_transfer_encoding_chunked:
-            parser->flags |= F_CHUNKED;
-            break;
-          case h_connection_upgrade:
-            parser->flags |= F_CONNECTION_UPGRADE;
-            break;
-          default:
-            break;
-        }
-
-        UPDATE_STATE(s_header_field_start);
-        REEXECUTE();
-      }
-
-      case s_header_value_discard_ws_almost_done:
-      {
-        STRICT_CHECK(ch != LF);
-        UPDATE_STATE(s_header_value_discard_lws);
-        break;
-      }
-
-      case s_header_value_discard_lws:
-      {
-        if (ch == ' ' || ch == '\t') {
-          UPDATE_STATE(s_header_value_discard_ws);
-          break;
-        } else {
-          switch (parser->header_state) {
-            case h_connection_keep_alive:
-              parser->flags |= F_CONNECTION_KEEP_ALIVE;
-              break;
-            case h_connection_close:
-              parser->flags |= F_CONNECTION_CLOSE;
-              break;
-            case h_connection_upgrade:
-              parser->flags |= F_CONNECTION_UPGRADE;
-              break;
-            case h_transfer_encoding_chunked:
-              parser->flags |= F_CHUNKED;
-              break;
-            default:
-              break;
-          }
-
-          /* header value was empty */
-          MARK(header_value);
-          UPDATE_STATE(s_header_field_start);
-          CALLBACK_DATA_NOADVANCE(header_value);
-          REEXECUTE();
-        }
-      }
-
-      case s_headers_almost_done:
-      {
-        STRICT_CHECK(ch != LF);
-
-        if (parser->flags & F_TRAILING) {
-          /* End of a chunked request */
-          UPDATE_STATE(s_message_done);
-          CALLBACK_NOTIFY_NOADVANCE(chunk_complete);
-          REEXECUTE();
-        }
-
-        /* Cannot use chunked encoding and a content-length header together
-           per the HTTP specification. */
-        if ((parser->flags & F_CHUNKED) &&
-            (parser->flags & F_CONTENTLENGTH)) {
-          SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
-          goto error;
-        }
-
-        UPDATE_STATE(s_headers_done);
-
-        /* Set this here so that on_headers_complete() callbacks can see it */
-        if ((parser->flags & F_UPGRADE) &&
-            (parser->flags & F_CONNECTION_UPGRADE)) {
-          /* For responses, "Upgrade: foo" and "Connection: upgrade" are
-           * mandatory only when it is a 101 Switching Protocols response,
-           * otherwise it is purely informational, to announce support.
-           */
-          parser->upgrade =
-              (parser->type == HTTP_REQUEST || parser->status_code == 101);
-        } else {
-          parser->upgrade = (parser->method == HTTP_CONNECT);
-        }
-
-        /* Here we call the headers_complete callback. This is somewhat
-         * different than other callbacks because if the user returns 1, we
-         * will interpret that as saying that this message has no body. This
-         * is needed for the annoying case of receiving a response to a HEAD
-         * request.
-         *
-         * We'd like to use CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so
-         * we have to simulate it by handling a change in errno below.
-         */
-        if (settings->on_headers_complete) {
-          switch (settings->on_headers_complete(parser)) {
-            case 0:
-              break;
-
-            case 2:
-              parser->upgrade = 1;
-
-              /* fall through */
-            case 1:
-              parser->flags |= F_SKIPBODY;
-              break;
-
-            default:
-              SET_ERRNO(HPE_CB_headers_complete);
-              RETURN(p - data); /* Error */
-          }
-        }
-
-        if (HTTP_PARSER_ERRNO(parser) != HPE_OK) {
-          RETURN(p - data);
-        }
-
-        REEXECUTE();
-      }
-
-      case s_headers_done:
-      {
-        int hasBody;
-        STRICT_CHECK(ch != LF);
-
-        parser->nread = 0;
-        nread = 0;
-
-        hasBody = parser->flags & F_CHUNKED ||
-          (parser->content_length > 0 && parser->content_length != ULLONG_MAX);
-        if (parser->upgrade && (parser->method == HTTP_CONNECT ||
-                                (parser->flags & F_SKIPBODY) || !hasBody)) {
-          /* Exit, the rest of the message is in a different protocol. */
-          UPDATE_STATE(NEW_MESSAGE());
-          CALLBACK_NOTIFY(message_complete);
-          RETURN((p - data) + 1);
-        }
-
-        if (parser->flags & F_SKIPBODY) {
-          UPDATE_STATE(NEW_MESSAGE());
-          CALLBACK_NOTIFY(message_complete);
-        } else if (parser->flags & F_CHUNKED) {
-          /* chunked encoding - ignore Content-Length header */
-          UPDATE_STATE(s_chunk_size_start);
-        } else {
-          if (parser->content_length == 0) {
-            /* Content-Length header given but zero: Content-Length: 0\r\n */
-            UPDATE_STATE(NEW_MESSAGE());
-            CALLBACK_NOTIFY(message_complete);
-          } else if (parser->content_length != ULLONG_MAX) {
-            /* Content-Length header given and non-zero */
-            UPDATE_STATE(s_body_identity);
-          } else {
-            if (!http_message_needs_eof(parser)) {
-              /* Assume content-length 0 - read the next */
-              UPDATE_STATE(NEW_MESSAGE());
-              CALLBACK_NOTIFY(message_complete);
-            } else {
-              /* Read body until EOF */
-              UPDATE_STATE(s_body_identity_eof);
-            }
-          }
-        }
-
-        break;
-      }
-
-      case s_body_identity:
-      {
-        uint64_t to_read = MIN(parser->content_length,
-                               (uint64_t) ((data + len) - p));
-
-        assert(parser->content_length != 0
-            && parser->content_length != ULLONG_MAX);
-
-        /* The difference between advancing content_length and p is because
-         * the latter will automaticaly advance on the next loop iteration.
-         * Further, if content_length ends up at 0, we want to see the last
-         * byte again for our message complete callback.
-         */
-        MARK(body);
-        parser->content_length -= to_read;
-        p += to_read - 1;
-
-        if (parser->content_length == 0) {
-          UPDATE_STATE(s_message_done);
-
-          /* Mimic CALLBACK_DATA_NOADVANCE() but with one extra byte.
-           *
-           * The alternative to doing this is to wait for the next byte to
-           * trigger the data callback, just as in every other case. The
-           * problem with this is that this makes it difficult for the test
-           * harness to distinguish between complete-on-EOF and
-           * complete-on-length. It's not clear that this distinction is
-           * important for applications, but let's keep it for now.
-           */
-          CALLBACK_DATA_(body, p - body_mark + 1, p - data);
-          REEXECUTE();
-        }
-
-        break;
-      }
-
-      /* read until EOF */
-      case s_body_identity_eof:
-        MARK(body);
-        p = data + len - 1;
-
-        break;
-
-      case s_message_done:
-        UPDATE_STATE(NEW_MESSAGE());
-        CALLBACK_NOTIFY(message_complete);
-        if (parser->upgrade) {
-          /* Exit, the rest of the message is in a different protocol. */
-          RETURN((p - data) + 1);
-        }
-        break;
-
-      case s_chunk_size_start:
-      {
-        assert(nread == 1);
-        assert(parser->flags & F_CHUNKED);
-
-        unhex_val = unhex[(unsigned char)ch];
-        if (UNLIKELY(unhex_val == -1)) {
-          SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
-          goto error;
-        }
-
-        parser->content_length = unhex_val;
-        UPDATE_STATE(s_chunk_size);
-        break;
-      }
-
-      case s_chunk_size:
-      {
-        uint64_t t;
-
-        assert(parser->flags & F_CHUNKED);
-
-        if (ch == CR) {
-          UPDATE_STATE(s_chunk_size_almost_done);
-          break;
-        }
-
-        unhex_val = unhex[(unsigned char)ch];
-
-        if (unhex_val == -1) {
-          if (ch == ';' || ch == ' ') {
-            UPDATE_STATE(s_chunk_parameters);
-            break;
-          }
-
-          SET_ERRNO(HPE_INVALID_CHUNK_SIZE);
-          goto error;
-        }
-
-        t = parser->content_length;
-        t *= 16;
-        t += unhex_val;
-
-        /* Overflow? Test against a conservative limit for simplicity. */
-        if (UNLIKELY((ULLONG_MAX - 16) / 16 < parser->content_length)) {
-          SET_ERRNO(HPE_INVALID_CONTENT_LENGTH);
-          goto error;
-        }
-
-        parser->content_length = t;
-        break;
-      }
-
-      case s_chunk_parameters:
-      {
-        assert(parser->flags & F_CHUNKED);
-        /* just ignore this shit. TODO check for overflow */
-        if (ch == CR) {
-          UPDATE_STATE(s_chunk_size_almost_done);
-          break;
-        }
-        break;
-      }
-
-      case s_chunk_size_almost_done:
-      {
-        assert(parser->flags & F_CHUNKED);
-        STRICT_CHECK(ch != LF);
-
-        parser->nread = 0;
-        nread = 0;
-
-        if (parser->content_length == 0) {
-          parser->flags |= F_TRAILING;
-          UPDATE_STATE(s_header_field_start);
-        } else {
-          UPDATE_STATE(s_chunk_data);
-        }
-        CALLBACK_NOTIFY(chunk_header);
-        break;
-      }
-
-      case s_chunk_data:
-      {
-        uint64_t to_read = MIN(parser->content_length,
-                               (uint64_t) ((data + len) - p));
-
-        assert(parser->flags & F_CHUNKED);
-        assert(parser->content_length != 0
-            && parser->content_length != ULLONG_MAX);
-
-        /* See the explanation in s_body_identity for why the content
-         * length and data pointers are managed this way.
-         */
-        MARK(body);
-        parser->content_length -= to_read;
-        p += to_read - 1;
-
-        if (parser->content_length == 0) {
-          UPDATE_STATE(s_chunk_data_almost_done);
-        }
-
-        break;
-      }
-
-      case s_chunk_data_almost_done:
-        assert(parser->flags & F_CHUNKED);
-        assert(parser->content_length == 0);
-        STRICT_CHECK(ch != CR);
-        UPDATE_STATE(s_chunk_data_done);
-        CALLBACK_DATA(body);
-        break;
-
-      case s_chunk_data_done:
-        assert(parser->flags & F_CHUNKED);
-        STRICT_CHECK(ch != LF);
-        parser->nread = 0;
-        nread = 0;
-        UPDATE_STATE(s_chunk_size_start);
-        CALLBACK_NOTIFY(chunk_complete);
-        break;
-
-      default:
-        assert(0 && "unhandled state");
-        SET_ERRNO(HPE_INVALID_INTERNAL_STATE);
-        goto error;
-    }
-  }
-
-  /* Run callbacks for any marks that we have leftover after we ran our of
-   * bytes. There should be at most one of these set, so it's OK to invoke
-   * them in series (unset marks will not result in callbacks).
-   *
-   * We use the NOADVANCE() variety of callbacks here because 'p' has already
-   * overflowed 'data' and this allows us to correct for the off-by-one that
-   * we'd otherwise have (since CALLBACK_DATA() is meant to be run with a 'p'
-   * value that's in-bounds).
-   */
-
-  assert(((header_field_mark ? 1 : 0) +
-          (header_value_mark ? 1 : 0) +
-          (url_mark ? 1 : 0)  +
-          (body_mark ? 1 : 0) +
-          (status_mark ? 1 : 0)) <= 1);
-
-  CALLBACK_DATA_NOADVANCE(header_field);
-  CALLBACK_DATA_NOADVANCE(header_value);
-  CALLBACK_DATA_NOADVANCE(url);
-  CALLBACK_DATA_NOADVANCE(body);
-  CALLBACK_DATA_NOADVANCE(status);
-
-  RETURN(len);
-
-error:
-  if (HTTP_PARSER_ERRNO(parser) == HPE_OK) {
-    SET_ERRNO(HPE_UNKNOWN);
-  }
-
-  RETURN(p - data);
-}
-
-
-/* Does the parser need to see an EOF to find the end of the message? */
-int
-http_message_needs_eof (const http_parser *parser)
-{
-  if (parser->type == HTTP_REQUEST) {
-    return 0;
-  }
-
-  /* See RFC 2616 section 4.4 */
-  if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
-      parser->status_code == 204 ||     /* No Content */
-      parser->status_code == 304 ||     /* Not Modified */
-      parser->flags & F_SKIPBODY) {     /* response to a HEAD request */
-    return 0;
-  }
-
-  if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) {
-    return 0;
-  }
-
-  return 1;
-}
-
-
-int
-http_should_keep_alive (const http_parser *parser)
-{
-  if (parser->http_major > 0 && parser->http_minor > 0) {
-    /* HTTP/1.1 */
-    if (parser->flags & F_CONNECTION_CLOSE) {
-      return 0;
-    }
-  } else {
-    /* HTTP/1.0 or earlier */
-    if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
-      return 0;
-    }
-  }
-
-  return !http_message_needs_eof(parser);
-}
-
-
-const char *
-http_method_str (enum http_method m)
-{
-  return ELEM_AT(method_strings, m, "<unknown>");
-}
-
-const char *
-http_status_str (enum http_status s)
-{
-  switch (s) {
-#define XX(num, name, string) case HTTP_STATUS_##name: return #string;
-    HTTP_STATUS_MAP(XX)
-#undef XX
-    default: return "<unknown>";
-  }
-}
-
-void
-http_parser_init (http_parser *parser, enum http_parser_type t)
-{
-  void *data = parser->data; /* preserve application data */
-  memset(parser, 0, sizeof(*parser));
-  parser->data = data;
-  parser->type = t;
-  parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
-  parser->http_errno = HPE_OK;
-}
-
-void
-http_parser_settings_init(http_parser_settings *settings)
-{
-  memset(settings, 0, sizeof(*settings));
-}
-
-const char *
-http_errno_name(enum http_errno err) {
-  assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab));
-  return http_strerror_tab[err].name;
-}
-
-const char *
-http_errno_description(enum http_errno err) {
-  assert(((size_t) err) < ARRAY_SIZE(http_strerror_tab));
-  return http_strerror_tab[err].description;
-}
-
-static enum http_host_state
-http_parse_host_char(enum http_host_state s, const char ch) {
-  switch(s) {
-    case s_http_userinfo:
-    case s_http_userinfo_start:
-      if (ch == '@') {
-        return s_http_host_start;
-      }
-
-      if (IS_USERINFO_CHAR(ch)) {
-        return s_http_userinfo;
-      }
-      break;
-
-    case s_http_host_start:
-      if (ch == '[') {
-        return s_http_host_v6_start;
-      }
-
-      if (IS_HOST_CHAR(ch)) {
-        return s_http_host;
-      }
-
-      break;
-
-    case s_http_host:
-      if (IS_HOST_CHAR(ch)) {
-        return s_http_host;
-      }
-
-    /* fall through */
-    case s_http_host_v6_end:
-      if (ch == ':') {
-        return s_http_host_port_start;
-      }
-
-      break;
-
-    case s_http_host_v6:
-      if (ch == ']') {
-        return s_http_host_v6_end;
-      }
-
-    /* fall through */
-    case s_http_host_v6_start:
-      if (IS_HEX(ch) || ch == ':' || ch == '.') {
-        return s_http_host_v6;
-      }
-
-      if (s == s_http_host_v6 && ch == '%') {
-        return s_http_host_v6_zone_start;
-      }
-      break;
-
-    case s_http_host_v6_zone:
-      if (ch == ']') {
-        return s_http_host_v6_end;
-      }
-
-    /* fall through */
-    case s_http_host_v6_zone_start:
-      /* RFC 6874 Zone ID consists of 1*( unreserved / pct-encoded) */
-      if (IS_ALPHANUM(ch) || ch == '%' || ch == '.' || ch == '-' || ch == '_' ||
-          ch == '~') {
-        return s_http_host_v6_zone;
-      }
-      break;
-
-    case s_http_host_port:
-    case s_http_host_port_start:
-      if (IS_NUM(ch)) {
-        return s_http_host_port;
-      }
-
-      break;
-
-    default:
-      break;
-  }
-  return s_http_host_dead;
-}
-
-static int
-http_parse_host(const char * buf, struct http_parser_url *u, int found_at) {
-  enum http_host_state s;
-
-  const char *p;
-  size_t buflen = u->field_data[UF_HOST].off + u->field_data[UF_HOST].len;
-
-  assert(u->field_set & (1 << UF_HOST));
-
-  u->field_data[UF_HOST].len = 0;
-
-  s = found_at ? s_http_userinfo_start : s_http_host_start;
-
-  for (p = buf + u->field_data[UF_HOST].off; p < buf + buflen; p++) {
-    enum http_host_state new_s = http_parse_host_char(s, *p);
-
-    if (new_s == s_http_host_dead) {
-      return 1;
-    }
-
-    switch(new_s) {
-      case s_http_host:
-        if (s != s_http_host) {
-          u->field_data[UF_HOST].off = p - buf;
-        }
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_v6:
-        if (s != s_http_host_v6) {
-          u->field_data[UF_HOST].off = p - buf;
-        }
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_v6_zone_start:
-      case s_http_host_v6_zone:
-        u->field_data[UF_HOST].len++;
-        break;
-
-      case s_http_host_port:
-        if (s != s_http_host_port) {
-          u->field_data[UF_PORT].off = p - buf;
-          u->field_data[UF_PORT].len = 0;
-          u->field_set |= (1 << UF_PORT);
-        }
-        u->field_data[UF_PORT].len++;
-        break;
-
-      case s_http_userinfo:
-        if (s != s_http_userinfo) {
-          u->field_data[UF_USERINFO].off = p - buf ;
-          u->field_data[UF_USERINFO].len = 0;
-          u->field_set |= (1 << UF_USERINFO);
-        }
-        u->field_data[UF_USERINFO].len++;
-        break;
-
-      default:
-        break;
-    }
-    s = new_s;
-  }
-
-  /* Make sure we don't end somewhere unexpected */
-  switch (s) {
-    case s_http_host_start:
-    case s_http_host_v6_start:
-    case s_http_host_v6:
-    case s_http_host_v6_zone_start:
-    case s_http_host_v6_zone:
-    case s_http_host_port_start:
-    case s_http_userinfo:
-    case s_http_userinfo_start:
-      return 1;
-    default:
-      break;
-  }
-
-  return 0;
-}
-
-void
-http_parser_url_init(struct http_parser_url *u) {
-  memset(u, 0, sizeof(*u));
-}
-
-int
-http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
-                      struct http_parser_url *u)
-{
-  enum state s;
-  const char *p;
-  enum http_parser_url_fields uf, old_uf;
-  int found_at = 0;
-
-  if (buflen == 0) {
-    return 1;
-  }
-
-  u->port = u->field_set = 0;
-  s = is_connect ? s_req_server_start : s_req_spaces_before_url;
-  old_uf = UF_MAX;
-
-  for (p = buf; p < buf + buflen; p++) {
-    s = parse_url_char(s, *p);
-
-    /* Figure out the next field that we're operating on */
-    switch (s) {
-      case s_dead:
-        return 1;
-
-      /* Skip delimeters */
-      case s_req_schema_slash:
-      case s_req_schema_slash_slash:
-      case s_req_server_start:
-      case s_req_query_string_start:
-      case s_req_fragment_start:
-        continue;
-
-      case s_req_schema:
-        uf = UF_SCHEMA;
-        break;
-
-      case s_req_server_with_at:
-        found_at = 1;
-
-      /* fall through */
-      case s_req_server:
-        uf = UF_HOST;
-        break;
-
-      case s_req_path:
-        uf = UF_PATH;
-        break;
-
-      case s_req_query_string:
-        uf = UF_QUERY;
-        break;
-
-      case s_req_fragment:
-        uf = UF_FRAGMENT;
-        break;
-
-      default:
-        assert(!"Unexpected state");
-        return 1;
-    }
-
-    /* Nothing's changed; soldier on */
-    if (uf == old_uf) {
-      u->field_data[uf].len++;
-      continue;
-    }
-
-    u->field_data[uf].off = p - buf;
-    u->field_data[uf].len = 1;
-
-    u->field_set |= (1 << uf);
-    old_uf = uf;
-  }
-
-  /* host must be present if there is a schema */
-  /* parsing http:///toto will fail */
-  if ((u->field_set & (1 << UF_SCHEMA)) &&
-      (u->field_set & (1 << UF_HOST)) == 0) {
-    return 1;
-  }
-
-  if (u->field_set & (1 << UF_HOST)) {
-    if (http_parse_host(buf, u, found_at) != 0) {
-      return 1;
-    }
-  }
-
-  /* CONNECT requests can only contain "hostname:port" */
-  if (is_connect && u->field_set != ((1 << UF_HOST)|(1 << UF_PORT))) {
-    return 1;
-  }
-
-  if (u->field_set & (1 << UF_PORT)) {
-    uint16_t off;
-    uint16_t len;
-    const char* p;
-    const char* end;
-    unsigned long v;
-
-    off = u->field_data[UF_PORT].off;
-    len = u->field_data[UF_PORT].len;
-    end = buf + off + len;
-
-    /* NOTE: The characters are already validated and are in the [0-9] range */
-    assert(off + len <= buflen && "Port number overflow");
-    v = 0;
-    for (p = buf + off; p < end; p++) {
-      v *= 10;
-      v += *p - '0';
-
-      /* Ports have a max value of 2^16 */
-      if (v > 0xffff) {
-        return 1;
-      }
-    }
-
-    u->port = (uint16_t) v;
-  }
-
-  return 0;
-}
-
-void
-http_parser_pause(http_parser *parser, int paused) {
-  /* Users should only be pausing/unpausing a parser that is not in an error
-   * state. In non-debug builds, there's not much that we can do about this
-   * other than ignore it.
-   */
-  if (HTTP_PARSER_ERRNO(parser) == HPE_OK ||
-      HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) {
-    uint32_t nread = parser->nread; /* used by the SET_ERRNO macro */
-    SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK);
-  } else {
-    assert(0 && "Attempting to pause parser in error state");
-  }
-}
-
-int
-http_body_is_final(const struct http_parser *parser) {
-    return parser->state == s_message_done;
-}
-
-unsigned long
-http_parser_version(void) {
-  return HTTP_PARSER_VERSION_MAJOR * 0x10000 |
-         HTTP_PARSER_VERSION_MINOR * 0x00100 |
-         HTTP_PARSER_VERSION_PATCH * 0x00001;
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/cpp/jni/DataLogJNI.cpp b/wpiutil/src/main/native/cpp/jni/DataLogJNI.cpp
new file mode 100644
index 0000000..997b90b
--- /dev/null
+++ b/wpiutil/src/main/native/cpp/jni/DataLogJNI.cpp
@@ -0,0 +1,357 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <jni.h>
+
+#include "edu_wpi_first_util_datalog_DataLogJNI.h"
+#include "wpi/DataLog.h"
+#include "wpi/jni_util.h"
+
+using namespace wpi::java;
+using namespace wpi::log;
+
+extern "C" {
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;DLjava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_create
+  (JNIEnv* env, jclass, jstring dir, jstring filename, jdouble period,
+   jstring extraHeader)
+{
+  return reinterpret_cast<jlong>(new DataLog{JStringRef{env, dir},
+                                             JStringRef{env, filename}, period,
+                                             JStringRef{env, extraHeader}});
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    setFilename
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_setFilename
+  (JNIEnv* env, jclass, jlong impl, jstring filename)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->SetFilename(JStringRef{env, filename});
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    flush
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_flush
+  (JNIEnv*, jclass, jlong impl)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->Flush();
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    pause
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_pause
+  (JNIEnv*, jclass, jlong impl)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->Pause();
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    resume
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_resume
+  (JNIEnv*, jclass, jlong impl)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->Resume();
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    start
+ * Signature: (JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;J)I
+ */
+JNIEXPORT jint JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_start
+  (JNIEnv* env, jclass, jlong impl, jstring name, jstring type,
+   jstring metadata, jlong timestamp)
+{
+  if (impl == 0) {
+    return 0;
+  }
+  return reinterpret_cast<DataLog*>(impl)->Start(
+      JStringRef{env, name}, JStringRef{env, type}, JStringRef{env, metadata},
+      timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    finish
+ * Signature: (JIJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_finish
+  (JNIEnv*, jclass, jlong impl, jint entry, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->Finish(entry, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    setMetadata
+ * Signature: (JILjava/lang/String;J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_setMetadata
+  (JNIEnv* env, jclass, jlong impl, jint entry, jstring metadata,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->SetMetadata(
+      entry, JStringRef{env, metadata}, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    close
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_close
+  (JNIEnv*, jclass, jlong impl)
+{
+  delete reinterpret_cast<DataLog*>(impl);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendRaw
+ * Signature: (JI[BJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendRaw
+  (JNIEnv* env, jclass, jlong impl, jint entry, jbyteArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  JByteArrayRef cvalue{env, value};
+  reinterpret_cast<DataLog*>(impl)->AppendRaw(
+      entry,
+      {reinterpret_cast<const uint8_t*>(cvalue.array().data()), cvalue.size()},
+      timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendBoolean
+ * Signature: (JIZJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendBoolean
+  (JNIEnv*, jclass, jlong impl, jint entry, jboolean value, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendBoolean(entry, value, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendInteger
+ * Signature: (JIJJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendInteger
+  (JNIEnv*, jclass, jlong impl, jint entry, jlong value, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendInteger(entry, value, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendFloat
+ * Signature: (JIFJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendFloat
+  (JNIEnv*, jclass, jlong impl, jint entry, jfloat value, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendFloat(entry, value, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendDouble
+ * Signature: (JIDJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendDouble
+  (JNIEnv*, jclass, jlong impl, jint entry, jdouble value, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendDouble(entry, value, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendString
+ * Signature: (JILjava/lang/String;J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendString
+  (JNIEnv* env, jclass, jlong impl, jint entry, jstring value, jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendString(entry, JStringRef{env, value},
+                                                 timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendBooleanArray
+ * Signature: (JI[ZJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendBooleanArray
+  (JNIEnv* env, jclass, jlong impl, jint entry, jbooleanArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendBooleanArray(
+      entry, JBooleanArrayRef{env, value}, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendIntegerArray
+ * Signature: (JI[JJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendIntegerArray
+  (JNIEnv* env, jclass, jlong impl, jint entry, jlongArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  JLongArrayRef jarr{env, value};
+  if constexpr (sizeof(jlong) == sizeof(int64_t)) {
+    reinterpret_cast<DataLog*>(impl)->AppendIntegerArray(
+        entry,
+        {reinterpret_cast<const int64_t*>(jarr.array().data()),
+         jarr.array().size()},
+        timestamp);
+  } else {
+    wpi::SmallVector<int64_t, 16> arr;
+    arr.reserve(jarr.size());
+    for (auto v : jarr.array()) {
+      arr.push_back(v);
+    }
+    reinterpret_cast<DataLog*>(impl)->AppendIntegerArray(entry, arr, timestamp);
+  }
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendFloatArray
+ * Signature: (JI[FJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendFloatArray
+  (JNIEnv* env, jclass, jlong impl, jint entry, jfloatArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendFloatArray(
+      entry, JFloatArrayRef{env, value}, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendDoubleArray
+ * Signature: (JI[DJ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendDoubleArray
+  (JNIEnv* env, jclass, jlong impl, jint entry, jdoubleArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendDoubleArray(
+      entry, JDoubleArrayRef{env, value}, timestamp);
+}
+
+/*
+ * Class:     edu_wpi_first_util_datalog_DataLogJNI
+ * Method:    appendStringArray
+ * Signature: (JI[Ljava/lang/Object;J)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_datalog_DataLogJNI_appendStringArray
+  (JNIEnv* env, jclass, jlong impl, jint entry, jobjectArray value,
+   jlong timestamp)
+{
+  if (impl == 0) {
+    return;
+  }
+  size_t len = env->GetArrayLength(value);
+  std::vector<std::string> arr;
+  arr.reserve(len);
+  for (size_t i = 0; i < len; ++i) {
+    JLocal<jstring> elem{
+        env, static_cast<jstring>(env->GetObjectArrayElement(value, i))};
+    if (!elem) {
+      return;
+    }
+    arr.emplace_back(JStringRef{env, elem}.str());
+  }
+  reinterpret_cast<DataLog*>(impl)->AppendStringArray(entry, arr, timestamp);
+}
+
+}  // extern "C"
diff --git a/wpiutil/src/main/native/cpp/jni/WPIUtilJNI.cpp b/wpiutil/src/main/native/cpp/jni/WPIUtilJNI.cpp
index e876d9c..5fa4ddf 100644
--- a/wpiutil/src/main/native/cpp/jni/WPIUtilJNI.cpp
+++ b/wpiutil/src/main/native/cpp/jni/WPIUtilJNI.cpp
@@ -4,14 +4,9 @@
 
 #include <jni.h>
 
-#include "../MulticastHandleManager.h"
 #include "edu_wpi_first_util_WPIUtilJNI.h"
-#include "wpi/DenseMap.h"
-#include "wpi/MulticastServiceAnnouncer.h"
-#include "wpi/MulticastServiceResolver.h"
-#include "wpi/PortForwarder.h"
+#include "fmt/format.h"
 #include "wpi/Synchronization.h"
-#include "wpi/UidVector.h"
 #include "wpi/jni_util.h"
 #include "wpi/timestamp.h"
 
@@ -21,8 +16,6 @@
 static uint64_t mockNow = 0;
 
 static JException interruptedEx;
-static JClass serviceDataCls;
-static JGlobal<jobjectArray> serviceDataEmptyArray;
 
 extern "C" {
 
@@ -37,17 +30,6 @@
     return JNI_ERR;
   }
 
-  serviceDataCls = JClass{env, "edu/wpi/first/util/ServiceData"};
-  if (!serviceDataCls) {
-    return JNI_ERR;
-  }
-
-  serviceDataEmptyArray = JGlobal<jobjectArray>{
-      env, env->NewObjectArray(0, serviceDataCls, nullptr)};
-  if (serviceDataEmptyArray == nullptr) {
-    return JNI_ERR;
-  }
-
   return JNI_VERSION_1_6;
 }
 
@@ -57,13 +39,23 @@
     return;
   }
 
-  serviceDataEmptyArray.free(env);
-  serviceDataCls.free(env);
   interruptedEx.free(env);
 }
 
 /*
  * Class:     edu_wpi_first_util_WPIUtilJNI
+ * Method:    writeStderr
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_util_WPIUtilJNI_writeStderr
+  (JNIEnv* env, jclass, jstring str)
+{
+  fmt::print(stderr, "{}", JStringRef{env, str});
+}
+
+/*
+ * Class:     edu_wpi_first_util_WPIUtilJNI
  * Method:    enableMockTime
  * Signature: ()V
  */
@@ -130,32 +122,6 @@
 
 /*
  * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    addPortForwarder
- * Signature: (ILjava/lang/String;I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_addPortForwarder
-  (JNIEnv* env, jclass, jint port, jstring remoteHost, jint remotePort)
-{
-  wpi::PortForwarder::GetInstance().Add(static_cast<unsigned int>(port),
-                                        JStringRef{env, remoteHost}.str(),
-                                        static_cast<unsigned int>(remotePort));
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    removePortForwarder
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_removePortForwarder
-  (JNIEnv* env, jclass, jint port)
-{
-  wpi::PortForwarder::GetInstance().Remove(port);
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
  * Method:    createEvent
  * Signature: (ZZ)I
  */
@@ -281,7 +247,7 @@
   JIntArrayRef handlesArr{env, handles};
   wpi::SmallVector<WPI_Handle, 8> signaledBuf;
   signaledBuf.resize(handlesArr.size());
-  wpi::span<const WPI_Handle> handlesArr2{
+  std::span<const WPI_Handle> handlesArr2{
       reinterpret_cast<const WPI_Handle*>(handlesArr.array().data()),
       handlesArr.size()};
 
@@ -305,7 +271,7 @@
   JIntArrayRef handlesArr{env, handles};
   wpi::SmallVector<WPI_Handle, 8> signaledBuf;
   signaledBuf.resize(handlesArr.size());
-  wpi::span<const WPI_Handle> handlesArr2{
+  std::span<const WPI_Handle> handlesArr2{
       reinterpret_cast<const WPI_Handle*>(handlesArr.array().data()),
       handlesArr.size()};
 
@@ -319,257 +285,4 @@
   return MakeJIntArray(env, signaled);
 }
 
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    createMulticastServiceAnnouncer
- * Signature: (Ljava/lang/String;Ljava/lang/String;I[Ljava/lang/Object;[Ljava/lang/Object;)I
- */
-JNIEXPORT jint JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_createMulticastServiceAnnouncer
-  (JNIEnv* env, jclass, jstring serviceName, jstring serviceType, jint port,
-   jobjectArray keys, jobjectArray values)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-
-  JStringRef serviceNameRef{env, serviceName};
-  JStringRef serviceTypeRef{env, serviceType};
-
-  size_t keysLen = env->GetArrayLength(keys);
-  wpi::SmallVector<std::pair<std::string, std::string>, 8> txtVec;
-  txtVec.reserve(keysLen);
-  for (size_t i = 0; i < keysLen; i++) {
-    JLocal<jstring> key{
-        env, static_cast<jstring>(env->GetObjectArrayElement(keys, i))};
-    JLocal<jstring> value{
-        env, static_cast<jstring>(env->GetObjectArrayElement(values, i))};
-
-    txtVec.emplace_back(std::pair<std::string, std::string>{
-        JStringRef{env, key}.str(), JStringRef{env, value}.str()});
-  }
-
-  auto announcer = std::make_unique<wpi::MulticastServiceAnnouncer>(
-      serviceNameRef.str(), serviceTypeRef.str(), port, txtVec);
-
-  size_t index = manager.handleIds.emplace_back(1);
-
-  manager.announcers[index] = std::move(announcer);
-
-  return static_cast<jint>(index);
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    freeMulticastServiceAnnouncer
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_freeMulticastServiceAnnouncer
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  manager.announcers[handle] = nullptr;
-  manager.handleIds.erase(handle);
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    startMulticastServiceAnnouncer
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_startMulticastServiceAnnouncer
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  announcer->Start();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    stopMulticastServiceAnnouncer
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_stopMulticastServiceAnnouncer
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  announcer->Stop();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    getMulticastServiceAnnouncerHasImplementation
- * Signature: (I)Z
- */
-JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_getMulticastServiceAnnouncerHasImplementation
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& announcer = manager.announcers[handle];
-  return announcer->HasImplementation();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    createMulticastServiceResolver
- * Signature: (Ljava/lang/String;)I
- */
-JNIEXPORT jint JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_createMulticastServiceResolver
-  (JNIEnv* env, jclass, jstring serviceType)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  JStringRef serviceTypeRef{env, serviceType};
-
-  auto resolver =
-      std::make_unique<wpi::MulticastServiceResolver>(serviceTypeRef.str());
-
-  size_t index = manager.handleIds.emplace_back(2);
-
-  manager.resolvers[index] = std::move(resolver);
-
-  return static_cast<jint>(index);
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    freeMulticastServiceResolver
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_freeMulticastServiceResolver
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  manager.resolvers[handle] = nullptr;
-  manager.handleIds.erase(handle);
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    startMulticastServiceResolver
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_startMulticastServiceResolver
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  resolver->Start();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    stopMulticastServiceResolver
- * Signature: (I)V
- */
-JNIEXPORT void JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_stopMulticastServiceResolver
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  resolver->Stop();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    getMulticastServiceResolverHasImplementation
- * Signature: (I)Z
- */
-JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_getMulticastServiceResolverHasImplementation
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  return resolver->HasImplementation();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    getMulticastServiceResolverEventHandle
- * Signature: (I)I
- */
-JNIEXPORT jint JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_getMulticastServiceResolverEventHandle
-  (JNIEnv* env, jclass, jint handle)
-{
-  auto& manager = wpi::GetMulticastManager();
-  std::scoped_lock lock{manager.mutex};
-  auto& resolver = manager.resolvers[handle];
-  return resolver->GetEventHandle();
-}
-
-/*
- * Class:     edu_wpi_first_util_WPIUtilJNI
- * Method:    getMulticastServiceResolverData
- * Signature: (I)[Ljava/lang/Object;
- */
-JNIEXPORT jobjectArray JNICALL
-Java_edu_wpi_first_util_WPIUtilJNI_getMulticastServiceResolverData
-  (JNIEnv* env, jclass, jint handle)
-{
-  static jmethodID constructor =
-      env->GetMethodID(serviceDataCls, "<init>",
-                       "(JILjava/lang/String;Ljava/lang/String;[Ljava/lang/"
-                       "String;[Ljava/lang/String;)V");
-  auto& manager = wpi::GetMulticastManager();
-  std::vector<wpi::MulticastServiceResolver::ServiceData> allData;
-  {
-    std::scoped_lock lock{manager.mutex};
-    auto& resolver = manager.resolvers[handle];
-    allData = resolver->GetData();
-  }
-  if (allData.empty()) {
-    return serviceDataEmptyArray;
-  }
-
-  JLocal<jobjectArray> returnData{
-      env, env->NewObjectArray(allData.size(), serviceDataCls, nullptr)};
-
-  for (auto&& data : allData) {
-    JLocal<jstring> serviceName{env, MakeJString(env, data.serviceName)};
-    JLocal<jstring> hostName{env, MakeJString(env, data.hostName)};
-
-    wpi::SmallVector<std::string_view, 8> keysRef;
-    wpi::SmallVector<std::string_view, 8> valuesRef;
-
-    size_t index = 0;
-    for (auto&& txt : data.txt) {
-      keysRef.emplace_back(txt.first);
-      valuesRef.emplace_back(txt.second);
-    }
-
-    JLocal<jobjectArray> keys{env, MakeJStringArray(env, keysRef)};
-    JLocal<jobjectArray> values{env, MakeJStringArray(env, valuesRef)};
-
-    JLocal<jobject> dataItem{
-        env, env->NewObject(serviceDataCls, constructor,
-                            static_cast<jlong>(data.ipv4Address),
-                            static_cast<jint>(data.port), serviceName.obj(),
-                            hostName.obj(), keys.obj(), values.obj())};
-
-    env->SetObjectArrayElement(returnData, index, dataItem);
-    index++;
-  }
-
-  return returnData;
-}
-
 }  // extern "C"
diff --git a/wpiutil/src/main/native/cpp/leb128.cpp b/wpiutil/src/main/native/cpp/leb128.cpp
index 9657883..17fbeb9 100644
--- a/wpiutil/src/main/native/cpp/leb128.cpp
+++ b/wpiutil/src/main/native/cpp/leb128.cpp
@@ -7,7 +7,6 @@
 #include "wpi/SpanExtras.h"
 #include "wpi/raw_istream.h"
 #include "wpi/raw_ostream.h"
-#include "wpi/span.h"
 
 namespace wpi {
 
@@ -98,7 +97,7 @@
   return true;
 }
 
-std::optional<uint64_t> Uleb128Reader::ReadOne(span<const uint8_t>* in) {
+std::optional<uint64_t> Uleb128Reader::ReadOne(std::span<const uint8_t>* in) {
   while (!in->empty()) {
     uint8_t byte = in->front();
     *in = wpi::drop_front(*in);
diff --git a/wpiutil/src/main/native/cpp/llvm/ConvertUTFWrapper.cpp b/wpiutil/src/main/native/cpp/llvm/ConvertUTFWrapper.cpp
deleted file mode 100644
index db190d0..0000000
--- a/wpiutil/src/main/native/cpp/llvm/ConvertUTFWrapper.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----===
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "wpi/ConvertUTF.h"
-#include "wpi/SmallVector.h"
-#include <string>
-#include <vector>
-
-namespace wpi {
-
-bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) {
-  const UTF32 *SourceStart = &Source;
-  const UTF32 *SourceEnd = SourceStart + 1;
-  UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr);
-  UTF8 *TargetEnd = TargetStart + 4;
-  ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd,
-                                           &TargetStart, TargetEnd,
-                                           strictConversion);
-  if (CR != conversionOK)
-    return false;
-
-  ResultPtr = reinterpret_cast<char*>(TargetStart);
-  return true;
-}
-
-bool hasUTF16ByteOrderMark(span<const char> S) {
-  return (S.size() >= 2 &&
-          ((S[0] == '\xff' && S[1] == '\xfe') ||
-           (S[0] == '\xfe' && S[1] == '\xff')));
-}
-
-bool convertUTF16ToUTF8String(span<const UTF16> SrcUTF16,
-                              SmallVectorImpl<char> &DstUTF8) {
-  assert(DstUTF8.empty());
-
-  // Avoid OOB by returning early on empty input.
-  if (SrcUTF16.empty())
-    return true;
-
-  const UTF16 *Src = SrcUTF16.begin();
-  const UTF16 *SrcEnd = SrcUTF16.end();
-
-  // Byteswap if necessary.
-  std::vector<UTF16> ByteSwapped;
-  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) {
-    ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
-    for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I)
-      ByteSwapped[I] = (ByteSwapped[I] << 8) | (ByteSwapped[I] >> 8);
-    Src = &ByteSwapped[0];
-    SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
-  }
-
-  // Skip the BOM for conversion.
-  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE)
-    Src++;
-
-  // Just allocate enough space up front.  We'll shrink it later.  Allocate
-  // enough that we can fit a null terminator without reallocating.
-  DstUTF8.resize(SrcUTF16.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
-  UTF8 *Dst = reinterpret_cast<UTF8*>(&DstUTF8[0]);
-  UTF8 *DstEnd = Dst + DstUTF8.size();
-
-  ConversionResult CR =
-      ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
-  assert(CR != targetExhausted);
-
-  if (CR != conversionOK) {
-    DstUTF8.clear();
-    return false;
-  }
-
-  DstUTF8.resize(reinterpret_cast<char*>(Dst) - &DstUTF8[0]);
-  DstUTF8.push_back(0);
-  DstUTF8.pop_back();
-  return true;
-}
-
-bool convertUTF8ToUTF16String(std::string_view SrcUTF8,
-                              SmallVectorImpl<UTF16> &DstUTF16) {
-  assert(DstUTF16.empty());
-
-  // Avoid OOB by returning early on empty input.
-  if (SrcUTF8.empty()) {
-    DstUTF16.push_back(0);
-    DstUTF16.pop_back();
-    return true;
-  }
-
-  const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.data());
-  const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.data() + SrcUTF8.size());
-
-  // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding
-  // as UTF-16 should always require the same amount or less code units than the
-  // UTF-8 encoding.  Allocate one extra byte for the null terminator though,
-  // so that someone calling DstUTF16.data() gets a null terminated string.
-  // We resize down later so we don't have to worry that this over allocates.
-  DstUTF16.resize(SrcUTF8.size()+1);
-  UTF16 *Dst = &DstUTF16[0];
-  UTF16 *DstEnd = Dst + DstUTF16.size();
-
-  ConversionResult CR =
-      ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
-  assert(CR != targetExhausted);
-
-  if (CR != conversionOK) {
-    DstUTF16.clear();
-    return false;
-  }
-
-  DstUTF16.resize(Dst - &DstUTF16[0]);
-  DstUTF16.push_back(0);
-  DstUTF16.pop_back();
-  return true;
-}
-
-} // end namespace wpi
-
diff --git a/wpiutil/src/main/native/cpp/llvm/ManagedStatic.cpp b/wpiutil/src/main/native/cpp/llvm/ManagedStatic.cpp
deleted file mode 100644
index a8c82bf..0000000
--- a/wpiutil/src/main/native/cpp/llvm/ManagedStatic.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===-- ManagedStatic.cpp - Static Global wrapper -------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the ManagedStatic class and wpi_shutdown().
-//
-//===----------------------------------------------------------------------===//
-
-#include "wpi/ManagedStatic.h"
-#include "wpi/mutex.h"
-#include <cassert>
-#include <mutex>
-using namespace wpi;
-
-static const ManagedStaticBase *StaticList = nullptr;
-static wpi::mutex *ManagedStaticMutex = nullptr;
-static std::once_flag mutex_init_flag;
-
-static void initializeMutex() {
-  ManagedStaticMutex = new wpi::mutex();
-}
-
-static wpi::mutex* getManagedStaticMutex() {
-  std::call_once(mutex_init_flag, initializeMutex);
-  return ManagedStaticMutex;
-}
-
-void ManagedStaticBase::RegisterManagedStatic(void* created,
-                                              void (*Deleter)(void*)) const {
-  std::scoped_lock Lock(*getManagedStaticMutex());
-
-  if (!Ptr.load(std::memory_order_relaxed)) {
-    void *Tmp = created;
-
-    Ptr.store(Tmp, std::memory_order_release);
-    DeleterFn = Deleter;
-
-    // Add to list of managed statics.
-    Next = StaticList;
-    StaticList = this;
-  }
-}
-
-void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
-                                              void (*Deleter)(void*)) const {
-  assert(Creator);
-  std::scoped_lock Lock(*getManagedStaticMutex());
-
-  if (!Ptr.load(std::memory_order_relaxed)) {
-    void *Tmp = Creator();
-
-    Ptr.store(Tmp, std::memory_order_release);
-    DeleterFn = Deleter;
-
-    // Add to list of managed statics.
-    Next = StaticList;
-    StaticList = this;
-  }
-}
-
-void ManagedStaticBase::destroy() const {
-  assert(DeleterFn && "ManagedStatic not initialized correctly!");
-  assert(StaticList == this &&
-         "Not destroyed in reverse order of construction?");
-  // Unlink from list.
-  StaticList = Next;
-  Next = nullptr;
-
-  // Destroy memory.
-  DeleterFn(Ptr);
-
-  // Cleanup.
-  Ptr = nullptr;
-  DeleterFn = nullptr;
-}
-
-/// wpi_shutdown - Deallocate and destroy all ManagedStatic variables.
-void wpi::wpi_shutdown() {
-  std::scoped_lock Lock(*getManagedStaticMutex());
-
-  while (StaticList)
-    StaticList->destroy();
-}
diff --git a/wpiutil/src/main/native/cpp/llvm/SmallVector.cpp b/wpiutil/src/main/native/cpp/llvm/SmallVector.cpp
deleted file mode 100644
index 974fec9..0000000
--- a/wpiutil/src/main/native/cpp/llvm/SmallVector.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//===- llvm/ADT/SmallVector.cpp - 'Normally small' vectors ----------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the SmallVector class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "wpi/SmallVector.h"
-#include "wpi/MemAlloc.h"
-using namespace wpi;
-
-/// grow_pod - This is an implementation of the grow() method which only works
-/// on POD-like datatypes and is out of line to reduce code duplication.
-void SmallVectorBase::grow_pod(void *FirstEl, size_t MinCapacity,
-                               size_t TSize) {
-  // Ensure we can fit the new capacity in 32 bits.
-  if (MinCapacity > UINT32_MAX)
-    report_bad_alloc_error("SmallVector capacity overflow during allocation");
-
-  size_t NewCapacity = 2 * capacity() + 1; // Always grow.
-  NewCapacity =
-      std::min(std::max(NewCapacity, MinCapacity), size_t(UINT32_MAX));
-
-  void *NewElts;
-  if (BeginX == FirstEl) {
-    NewElts = safe_malloc(NewCapacity * TSize);
-
-    // Copy the elements over.  No need to run dtors on PODs.
-    memcpy(NewElts, this->BeginX, size() * TSize);
-  } else {
-    // If this wasn't grown from the inline copy, grow the allocated space.
-    NewElts = safe_realloc(this->BeginX, NewCapacity * TSize);
-  }
-
-  this->BeginX = NewElts;
-  this->Capacity = NewCapacity;
-}
diff --git a/wpiutil/src/main/native/cpp/raw_socket_istream.cpp b/wpiutil/src/main/native/cpp/raw_socket_istream.cpp
deleted file mode 100644
index c6b759e..0000000
--- a/wpiutil/src/main/native/cpp/raw_socket_istream.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/raw_socket_istream.h"
-
-#include "wpi/NetworkStream.h"
-
-using namespace wpi;
-
-void raw_socket_istream::read_impl(void* data, size_t len) {
-  char* cdata = static_cast<char*>(data);
-  size_t pos = 0;
-
-  while (pos < len) {
-    NetworkStream::Error err;
-    size_t count = m_stream.receive(&cdata[pos], len - pos, &err, m_timeout);
-    if (count == 0) {
-      error_detected();
-      break;
-    }
-    pos += count;
-  }
-  set_read_count(pos);
-}
-
-void raw_socket_istream::close() {
-  m_stream.close();
-}
-
-size_t raw_socket_istream::in_avail() const {
-  return 0;
-}
diff --git a/wpiutil/src/main/native/cpp/raw_socket_ostream.cpp b/wpiutil/src/main/native/cpp/raw_socket_ostream.cpp
deleted file mode 100644
index af01c84..0000000
--- a/wpiutil/src/main/native/cpp/raw_socket_ostream.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/raw_socket_ostream.h"
-
-#include "wpi/NetworkStream.h"
-
-using namespace wpi;
-
-raw_socket_ostream::~raw_socket_ostream() {
-  flush();
-  if (m_shouldClose) {
-    close();
-  }
-}
-
-void raw_socket_ostream::write_impl(const char* data, size_t len) {
-  size_t pos = 0;
-
-  while (pos < len) {
-    NetworkStream::Error err;
-    size_t count = m_stream.send(&data[pos], len - pos, &err);
-    if (count == 0) {
-      error_detected();
-      return;
-    }
-    pos += count;
-  }
-}
-
-uint64_t raw_socket_ostream::current_pos() const {
-  return 0;
-}
-
-void raw_socket_ostream::close() {
-  if (!m_shouldClose) {
-    return;
-  }
-  flush();
-  m_stream.close();
-}
diff --git a/wpiutil/src/main/native/cpp/raw_uv_ostream.cpp b/wpiutil/src/main/native/cpp/raw_uv_ostream.cpp
deleted file mode 100644
index f055a2a..0000000
--- a/wpiutil/src/main/native/cpp/raw_uv_ostream.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/raw_uv_ostream.h"
-
-#include <cstring>
-
-using namespace wpi;
-
-void raw_uv_ostream::write_impl(const char* data, size_t len) {
-  while (len > 0) {
-    // allocate additional buffers as required
-    if (m_left == 0) {
-      m_bufs.emplace_back(m_alloc());
-      // we want bufs() to always be valid, so set len=0 and keep track of the
-      // amount of space remaining separately
-      m_left = m_bufs.back().len;
-      m_bufs.back().len = 0;
-      assert(m_left != 0);
-    }
-
-    size_t amt = (std::min)(m_left, len);
-    auto& buf = m_bufs.back();
-    std::memcpy(buf.base + buf.len, data, amt);
-    data += amt;
-    len -= amt;
-    buf.len += amt;
-    m_left -= amt;
-  }
-}
-
-uint64_t raw_uv_ostream::current_pos() const {
-  uint64_t size = 0;
-  for (auto&& buf : m_bufs) {
-    size += buf.len;
-  }
-  return size;
-}
diff --git a/wpiutil/src/main/native/cpp/sha1.cpp b/wpiutil/src/main/native/cpp/sha1.cpp
index 8ec7cb1..98dc543 100644
--- a/wpiutil/src/main/native/cpp/sha1.cpp
+++ b/wpiutil/src/main/native/cpp/sha1.cpp
@@ -217,7 +217,7 @@
 }
 
 void SHA1::Update(std::string_view s) {
-  raw_mem_istream is(span<const char>(s.data(), s.size()));
+  raw_mem_istream is(std::span<const char>(s.data(), s.size()));
   Update(is);
 }
 
diff --git a/wpiutil/src/main/native/cpp/uv/Async.cpp b/wpiutil/src/main/native/cpp/uv/Async.cpp
deleted file mode 100644
index c9d698e..0000000
--- a/wpiutil/src/main/native/cpp/uv/Async.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Async.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-Async<>::~Async() noexcept {
-  if (auto loop = m_loop.lock()) {
-    Close();
-  } else {
-    ForceClosed();
-  }
-}
-
-std::shared_ptr<Async<>> Async<>::Create(const std::shared_ptr<Loop>& loop) {
-  auto h = std::make_shared<Async>(loop, private_init{});
-  int err = uv_async_init(loop->GetRaw(), h->GetRaw(), [](uv_async_t* handle) {
-    Async& h = *static_cast<Async*>(handle->data);
-    h.wakeup();
-  });
-  if (err < 0) {
-    loop->ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Check.cpp b/wpiutil/src/main/native/cpp/uv/Check.cpp
deleted file mode 100644
index 97265d4..0000000
--- a/wpiutil/src/main/native/cpp/uv/Check.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Check.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Check> Check::Create(Loop& loop) {
-  auto h = std::make_shared<Check>(private_init{});
-  int err = uv_check_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Check::Start() {
-  Invoke(&uv_check_start, GetRaw(), [](uv_check_t* handle) {
-    Check& h = *static_cast<Check*>(handle->data);
-    h.check();
-  });
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/FsEvent.cpp b/wpiutil/src/main/native/cpp/uv/FsEvent.cpp
deleted file mode 100644
index 3c83d1d..0000000
--- a/wpiutil/src/main/native/cpp/uv/FsEvent.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/FsEvent.h"
-
-#include <cstdlib>
-
-#include "wpi/SmallString.h"
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<FsEvent> FsEvent::Create(Loop& loop) {
-  auto h = std::make_shared<FsEvent>(private_init{});
-  int err = uv_fs_event_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void FsEvent::Start(std::string_view path, unsigned int flags) {
-  SmallString<128> pathBuf{path};
-  Invoke(
-      &uv_fs_event_start, GetRaw(),
-      [](uv_fs_event_t* handle, const char* filename, int events, int status) {
-        FsEvent& h = *static_cast<FsEvent*>(handle->data);
-        if (status < 0) {
-          h.ReportError(status);
-        } else {
-          h.fsEvent(filename, events);
-        }
-      },
-      pathBuf.c_str(), flags);
-}
-
-std::string FsEvent::GetPath() {
-  // Per the libuv docs, GetPath() always gives us a null-terminated string.
-  // common case should be small
-  char buf[128];
-  size_t size = 128;
-  int r = uv_fs_event_getpath(GetRaw(), buf, &size);
-  if (r == 0) {
-    return buf;
-  } else if (r == UV_ENOBUFS) {
-    // need to allocate a big enough buffer
-    char* buf2 = static_cast<char*>(std::malloc(size));
-    r = uv_fs_event_getpath(GetRaw(), buf2, &size);
-    if (r == 0) {
-      std::string out{buf2};
-      std::free(buf2);
-      return out;
-    }
-    std::free(buf2);
-  }
-  ReportError(r);
-  return std::string{};
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/GetAddrInfo.cpp b/wpiutil/src/main/native/cpp/uv/GetAddrInfo.cpp
deleted file mode 100644
index 2e6e38f..0000000
--- a/wpiutil/src/main/native/cpp/uv/GetAddrInfo.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/GetAddrInfo.h"
-
-#include "wpi/SmallString.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/util.h"
-
-namespace wpi::uv {
-
-GetAddrInfoReq::GetAddrInfoReq() {
-  error = [this](Error err) { GetLoop().error(err); };
-}
-
-void GetAddrInfo(Loop& loop, const std::shared_ptr<GetAddrInfoReq>& req,
-                 std::string_view node, std::string_view service,
-                 const addrinfo* hints) {
-  SmallString<128> nodeStr{node};
-  SmallString<128> serviceStr{service};
-  int err = uv_getaddrinfo(
-      loop.GetRaw(), req->GetRaw(),
-      [](uv_getaddrinfo_t* req, int status, addrinfo* res) {
-        auto& h = *static_cast<GetAddrInfoReq*>(req->data);
-        if (status < 0) {
-          h.ReportError(status);
-        } else {
-          h.resolved(*res);
-        }
-        uv_freeaddrinfo(res);
-        h.Release();  // this is always a one-shot
-      },
-      node.empty() ? nullptr : nodeStr.c_str(),
-      service.empty() ? nullptr : serviceStr.c_str(), hints);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    req->Keep();
-  }
-}
-
-void GetAddrInfo(Loop& loop, std::function<void(const addrinfo&)> callback,
-                 std::string_view node, std::string_view service,
-                 const addrinfo* hints) {
-  auto req = std::make_shared<GetAddrInfoReq>();
-  req->resolved.connect(std::move(callback));
-  GetAddrInfo(loop, req, node, service, hints);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/GetNameInfo.cpp b/wpiutil/src/main/native/cpp/uv/GetNameInfo.cpp
deleted file mode 100644
index 4e662f3..0000000
--- a/wpiutil/src/main/native/cpp/uv/GetNameInfo.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/GetNameInfo.h"
-
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/util.h"
-
-namespace wpi::uv {
-
-GetNameInfoReq::GetNameInfoReq() {
-  error = [this](Error err) { GetLoop().error(err); };
-}
-
-void GetNameInfo(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                 const sockaddr& addr, int flags) {
-  int err = uv_getnameinfo(
-      loop.GetRaw(), req->GetRaw(),
-      [](uv_getnameinfo_t* req, int status, const char* hostname,
-         const char* service) {
-        auto& h = *static_cast<GetNameInfoReq*>(req->data);
-        if (status < 0) {
-          h.ReportError(status);
-        } else {
-          h.resolved(hostname, service);
-        }
-        h.Release();  // this is always a one-shot
-      },
-      &addr, flags);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    req->Keep();
-  }
-}
-
-void GetNameInfo(Loop& loop,
-                 std::function<void(const char*, const char*)> callback,
-                 const sockaddr& addr, int flags) {
-  auto req = std::make_shared<GetNameInfoReq>();
-  req->resolved.connect(std::move(callback));
-  GetNameInfo(loop, req, addr, flags);
-}
-
-void GetNameInfo4(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                  std::string_view ip, unsigned int port, int flags) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    GetNameInfo(loop, req, reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void GetNameInfo4(Loop& loop,
-                  std::function<void(const char*, const char*)> callback,
-                  std::string_view ip, unsigned int port, int flags) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    GetNameInfo(loop, std::move(callback),
-                reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void GetNameInfo6(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                  std::string_view ip, unsigned int port, int flags) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    GetNameInfo(loop, req, reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void GetNameInfo6(Loop& loop,
-                  std::function<void(const char*, const char*)> callback,
-                  std::string_view ip, unsigned int port, int flags) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    GetNameInfo(loop, std::move(callback),
-                reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Handle.cpp b/wpiutil/src/main/native/cpp/uv/Handle.cpp
deleted file mode 100644
index 74c4c60..0000000
--- a/wpiutil/src/main/native/cpp/uv/Handle.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Handle.h"
-
-using namespace wpi::uv;
-
-Handle::~Handle() noexcept {
-  if (!m_closed && m_uv_handle->type != UV_UNKNOWN_HANDLE) {
-    uv_close(m_uv_handle, [](uv_handle_t* uv_handle) { std::free(uv_handle); });
-  } else {
-    std::free(m_uv_handle);
-  }
-}
-
-void Handle::Close() noexcept {
-  if (!IsClosing()) {
-    uv_close(m_uv_handle, [](uv_handle_t* handle) {
-      Handle& h = *static_cast<Handle*>(handle->data);
-      h.closed();
-      h.Release();  // free ourselves
-    });
-    m_closed = true;
-  }
-}
-
-void Handle::AllocBuf(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
-  auto& h = *static_cast<Handle*>(handle->data);
-  *buf = h.m_allocBuf(size);
-}
-
-void Handle::DefaultFreeBuf(Buffer& buf) {
-  buf.Deallocate();
-}
diff --git a/wpiutil/src/main/native/cpp/uv/Idle.cpp b/wpiutil/src/main/native/cpp/uv/Idle.cpp
deleted file mode 100644
index 6bf8602..0000000
--- a/wpiutil/src/main/native/cpp/uv/Idle.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Idle.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Idle> Idle::Create(Loop& loop) {
-  auto h = std::make_shared<Idle>(private_init{});
-  int err = uv_idle_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Idle::Start() {
-  Invoke(&uv_idle_start, GetRaw(), [](uv_idle_t* handle) {
-    Idle& h = *static_cast<Idle*>(handle->data);
-    h.idle();
-  });
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Loop.cpp b/wpiutil/src/main/native/cpp/uv/Loop.cpp
deleted file mode 100644
index c5b7163..0000000
--- a/wpiutil/src/main/native/cpp/uv/Loop.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Loop.h"
-
-using namespace wpi::uv;
-
-Loop::Loop(const private_init&) noexcept {
-#ifndef _WIN32
-  // Ignore SIGPIPE (see https://github.com/joyent/libuv/issues/1254)
-  static bool once = []() {
-    signal(SIGPIPE, SIG_IGN);
-    return true;
-  }();
-  (void)once;
-#endif
-}
-
-Loop::~Loop() noexcept {
-  if (m_loop) {
-    m_loop->data = nullptr;
-    Close();
-  }
-}
-
-std::shared_ptr<Loop> Loop::Create() {
-  auto loop = std::make_shared<Loop>(private_init{});
-  if (uv_loop_init(&loop->m_loopStruct) < 0) {
-    return nullptr;
-  }
-  loop->m_loop = &loop->m_loopStruct;
-  loop->m_loop->data = loop.get();
-  return loop;
-}
-
-std::shared_ptr<Loop> Loop::GetDefault() {
-  static std::shared_ptr<Loop> loop = std::make_shared<Loop>(private_init{});
-  loop->m_loop = uv_default_loop();
-  if (!loop->m_loop) {
-    return nullptr;
-  }
-  loop->m_loop->data = loop.get();
-  return loop;
-}
-
-void Loop::Close() {
-  int err = uv_loop_close(m_loop);
-  if (err < 0) {
-    ReportError(err);
-  }
-}
-
-void Loop::Walk(function_ref<void(Handle&)> callback) {
-  uv_walk(
-      m_loop,
-      [](uv_handle_t* handle, void* func) {
-        auto& h = *static_cast<Handle*>(handle->data);
-        auto& f = *static_cast<function_ref<void(Handle&)>*>(func);
-        f(h);
-      },
-      &callback);
-}
-
-void Loop::Fork() {
-  int err = uv_loop_fork(m_loop);
-  if (err < 0) {
-    ReportError(err);
-  }
-}
diff --git a/wpiutil/src/main/native/cpp/uv/NameToAddr.cpp b/wpiutil/src/main/native/cpp/uv/NameToAddr.cpp
deleted file mode 100644
index 23ec6da..0000000
--- a/wpiutil/src/main/native/cpp/uv/NameToAddr.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/util.h"  // NOLINT(build/include_order)
-
-#include <cstring>
-
-#include "wpi/SmallString.h"
-
-namespace wpi::uv {
-
-int NameToAddr(std::string_view ip, unsigned int port, sockaddr_in* addr) {
-  if (ip.empty()) {
-    std::memset(addr, 0, sizeof(sockaddr_in));
-    addr->sin_family = PF_INET;
-    addr->sin_addr.s_addr = INADDR_ANY;
-    addr->sin_port = htons(port);
-    return 0;
-  } else {
-    SmallString<128> ipBuf{ip};
-    return uv_ip4_addr(ipBuf.c_str(), port, addr);
-  }
-}
-
-int NameToAddr(std::string_view ip, unsigned int port, sockaddr_in6* addr) {
-  if (ip.empty()) {
-    std::memset(addr, 0, sizeof(sockaddr_in6));
-    addr->sin6_family = PF_INET6;
-    addr->sin6_addr = in6addr_any;
-    addr->sin6_port = htons(port);
-    return 0;
-  } else {
-    SmallString<128> ipBuf{ip};
-    return uv_ip6_addr(ipBuf.c_str(), port, addr);
-  }
-}
-
-int NameToAddr(std::string_view ip, in_addr* addr) {
-  if (ip.empty()) {
-    addr->s_addr = INADDR_ANY;
-    return 0;
-  } else {
-    SmallString<128> ipBuf{ip};
-    return uv_inet_pton(AF_INET, ipBuf.c_str(), addr);
-  }
-}
-
-int NameToAddr(std::string_view ip, in6_addr* addr) {
-  if (ip.empty()) {
-    *addr = in6addr_any;
-    return 0;
-  } else {
-    SmallString<128> ipBuf{ip};
-    return uv_inet_pton(AF_INET6, ipBuf.c_str(), addr);
-  }
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/NetworkStream.cpp b/wpiutil/src/main/native/cpp/uv/NetworkStream.cpp
deleted file mode 100644
index 0bc3337..0000000
--- a/wpiutil/src/main/native/cpp/uv/NetworkStream.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/NetworkStream.h"
-
-namespace wpi::uv {
-
-ConnectReq::ConnectReq() {
-  error = [this](Error err) { GetStream().error(err); };
-}
-
-void NetworkStream::Listen(int backlog) {
-  Invoke(&uv_listen, GetRawStream(), backlog,
-         [](uv_stream_t* handle, int status) {
-           auto& h = *static_cast<NetworkStream*>(handle->data);
-           if (status < 0) {
-             h.ReportError(status);
-           } else {
-             h.connection();
-           }
-         });
-}
-
-void NetworkStream::Listen(std::function<void()> callback, int backlog) {
-  connection.connect(std::move(callback));
-  Listen(backlog);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Pipe.cpp b/wpiutil/src/main/native/cpp/uv/Pipe.cpp
deleted file mode 100644
index b5ca673..0000000
--- a/wpiutil/src/main/native/cpp/uv/Pipe.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Pipe.h"
-
-#include <cstdlib>
-
-#include "wpi/SmallString.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Pipe> Pipe::Create(Loop& loop, bool ipc) {
-  auto h = std::make_shared<Pipe>(private_init{});
-  int err = uv_pipe_init(loop.GetRaw(), h->GetRaw(), ipc ? 1 : 0);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Pipe::Reuse(std::function<void()> callback, bool ipc) {
-  if (IsClosing()) {
-    return;
-  }
-  if (!m_reuseData) {
-    m_reuseData = std::make_unique<ReuseData>();
-  }
-  m_reuseData->callback = std::move(callback);
-  m_reuseData->ipc = ipc;
-  uv_close(GetRawHandle(), [](uv_handle_t* handle) {
-    Pipe& h = *static_cast<Pipe*>(handle->data);
-    if (!h.m_reuseData) {
-      return;
-    }
-    auto data = std::move(h.m_reuseData);
-    auto err =
-        uv_pipe_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->ipc ? 1 : 0);
-    if (err < 0) {
-      h.ReportError(err);
-      return;
-    }
-    data->callback();
-  });
-}
-
-std::shared_ptr<Pipe> Pipe::Accept() {
-  auto client = Create(GetLoopRef(), GetRaw()->ipc);
-  if (!client) {
-    return nullptr;
-  }
-  if (!Accept(client)) {
-    client->Release();
-    return nullptr;
-  }
-  return client;
-}
-
-Pipe* Pipe::DoAccept() {
-  return Accept().get();
-}
-
-void Pipe::Bind(std::string_view name) {
-  SmallString<128> nameBuf{name};
-  Invoke(&uv_pipe_bind, GetRaw(), nameBuf.c_str());
-}
-
-void Pipe::Connect(std::string_view name,
-                   const std::shared_ptr<PipeConnectReq>& req) {
-  SmallString<128> nameBuf{name};
-  uv_pipe_connect(req->GetRaw(), GetRaw(), nameBuf.c_str(),
-                  [](uv_connect_t* req, int status) {
-                    auto& h = *static_cast<PipeConnectReq*>(req->data);
-                    if (status < 0) {
-                      h.ReportError(status);
-                    } else {
-                      h.connected();
-                    }
-                    h.Release();  // this is always a one-shot
-                  });
-  req->Keep();
-}
-
-void Pipe::Connect(std::string_view name, std::function<void()> callback) {
-  auto req = std::make_shared<PipeConnectReq>();
-  req->connected.connect(std::move(callback));
-  Connect(name, req);
-}
-
-std::string Pipe::GetSock() {
-  // Per libuv docs, the returned buffer is NOT null terminated.
-  // common case should be small
-  char buf[128];
-  size_t size = 128;
-  int r = uv_pipe_getsockname(GetRaw(), buf, &size);
-  if (r == 0) {
-    return std::string{buf, size};
-  } else if (r == UV_ENOBUFS) {
-    // need to allocate a big enough buffer
-    char* buf2 = static_cast<char*>(std::malloc(size));
-    r = uv_pipe_getsockname(GetRaw(), buf2, &size);
-    if (r == 0) {
-      std::string out{buf2, size};
-      std::free(buf2);
-      return out;
-    }
-    std::free(buf2);
-  }
-  ReportError(r);
-  return std::string{};
-}
-
-std::string Pipe::GetPeer() {
-  // Per libuv docs, the returned buffer is NOT null terminated.
-  // common case should be small
-  char buf[128];
-  size_t size = 128;
-  int r = uv_pipe_getpeername(GetRaw(), buf, &size);
-  if (r == 0) {
-    return std::string{buf, size};
-  } else if (r == UV_ENOBUFS) {
-    // need to allocate a big enough buffer
-    char* buf2 = static_cast<char*>(std::malloc(size));
-    r = uv_pipe_getpeername(GetRaw(), buf2, &size);
-    if (r == 0) {
-      std::string out{buf2, size};
-      std::free(buf2);
-      return out;
-    }
-    std::free(buf2);
-  }
-  ReportError(r);
-  return std::string{};
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Poll.cpp b/wpiutil/src/main/native/cpp/uv/Poll.cpp
deleted file mode 100644
index 090a40b..0000000
--- a/wpiutil/src/main/native/cpp/uv/Poll.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Poll.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Poll> Poll::Create(Loop& loop, int fd) {
-  auto h = std::make_shared<Poll>(private_init{});
-  int err = uv_poll_init(loop.GetRaw(), h->GetRaw(), fd);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-std::shared_ptr<Poll> Poll::CreateSocket(Loop& loop, uv_os_sock_t sock) {
-  auto h = std::make_shared<Poll>(private_init{});
-  int err = uv_poll_init_socket(loop.GetRaw(), h->GetRaw(), sock);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Poll::Reuse(int fd, std::function<void()> callback) {
-  if (IsClosing()) {
-    return;
-  }
-  if (!m_reuseData) {
-    m_reuseData = std::make_unique<ReuseData>();
-  }
-  m_reuseData->callback = std::move(callback);
-  m_reuseData->isSocket = false;
-  m_reuseData->fd = fd;
-  uv_close(GetRawHandle(), [](uv_handle_t* handle) {
-    Poll& h = *static_cast<Poll*>(handle->data);
-    if (!h.m_reuseData || h.m_reuseData->isSocket) {
-      return;  // just in case
-    }
-    auto data = std::move(h.m_reuseData);
-    int err = uv_poll_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->fd);
-    if (err < 0) {
-      h.ReportError(err);
-      return;
-    }
-    data->callback();
-  });
-}
-
-void Poll::ReuseSocket(uv_os_sock_t sock, std::function<void()> callback) {
-  if (IsClosing()) {
-    return;
-  }
-  if (!m_reuseData) {
-    m_reuseData = std::make_unique<ReuseData>();
-  }
-  m_reuseData->callback = std::move(callback);
-  m_reuseData->isSocket = true;
-  m_reuseData->sock = sock;
-  uv_close(GetRawHandle(), [](uv_handle_t* handle) {
-    Poll& h = *static_cast<Poll*>(handle->data);
-    if (!h.m_reuseData || !h.m_reuseData->isSocket) {
-      return;  // just in case
-    }
-    auto data = std::move(h.m_reuseData);
-    int err = uv_poll_init(h.GetLoopRef().GetRaw(), h.GetRaw(), data->sock);
-    if (err < 0) {
-      h.ReportError(err);
-      return;
-    }
-    data->callback();
-  });
-}
-
-void Poll::Start(int events) {
-  Invoke(&uv_poll_start, GetRaw(), events,
-         [](uv_poll_t* handle, int status, int events) {
-           Poll& h = *static_cast<Poll*>(handle->data);
-           if (status < 0) {
-             h.ReportError(status);
-           } else {
-             h.pollEvent(events);
-           }
-         });
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Prepare.cpp b/wpiutil/src/main/native/cpp/uv/Prepare.cpp
deleted file mode 100644
index 048fd08..0000000
--- a/wpiutil/src/main/native/cpp/uv/Prepare.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Prepare.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Prepare> Prepare::Create(Loop& loop) {
-  auto h = std::make_shared<Prepare>(private_init{});
-  int err = uv_prepare_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Prepare::Start() {
-  Invoke(&uv_prepare_start, GetRaw(), [](uv_prepare_t* handle) {
-    Prepare& h = *static_cast<Prepare*>(handle->data);
-    h.prepare();
-  });
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Process.cpp b/wpiutil/src/main/native/cpp/uv/Process.cpp
deleted file mode 100644
index c8d5229..0000000
--- a/wpiutil/src/main/native/cpp/uv/Process.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Process.h"
-
-#include "wpi/SmallString.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Pipe.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
-                                             span<const Option> options) {
-  // convert Option array to libuv structure
-  uv_process_options_t coptions;
-
-  coptions.exit_cb = [](uv_process_t* handle, int64_t status, int signal) {
-    auto& h = *static_cast<Process*>(handle->data);
-    h.exited(status, signal);
-  };
-
-  SmallString<128> fileBuf{file};
-  coptions.file = fileBuf.c_str();
-  coptions.cwd = nullptr;
-  coptions.flags = 0;
-  coptions.uid = 0;
-  coptions.gid = 0;
-
-  SmallVector<char*, 4> argsBuf;
-  SmallVector<char*, 4> envBuf;
-  struct StdioContainer : public uv_stdio_container_t {
-    StdioContainer() {
-      flags = UV_IGNORE;
-      data.fd = 0;
-    }
-  };
-  SmallVector<StdioContainer, 4> stdioBuf;
-
-  for (auto&& o : options) {
-    switch (o.m_type) {
-      case Option::kArg:
-        argsBuf.push_back(const_cast<char*>(o.m_data.str));
-        break;
-      case Option::kEnv:
-        envBuf.push_back(const_cast<char*>(o.m_data.str));
-        break;
-      case Option::kCwd:
-        coptions.cwd = o.m_data.str[0] == '\0' ? nullptr : o.m_data.str;
-        break;
-      case Option::kUid:
-        coptions.uid = o.m_data.uid;
-        coptions.flags |= UV_PROCESS_SETUID;
-        break;
-      case Option::kGid:
-        coptions.gid = o.m_data.gid;
-        coptions.flags |= UV_PROCESS_SETGID;
-        break;
-      case Option::kSetFlags:
-        coptions.flags |= o.m_data.flags;
-        break;
-      case Option::kClearFlags:
-        coptions.flags &= ~o.m_data.flags;
-        break;
-      case Option::kStdioIgnore: {
-        size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) {
-          stdioBuf.resize(index + 1);
-        }
-        stdioBuf[index].flags = UV_IGNORE;
-        stdioBuf[index].data.fd = 0;
-        break;
-      }
-      case Option::kStdioInheritFd: {
-        size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) {
-          stdioBuf.resize(index + 1);
-        }
-        stdioBuf[index].flags = UV_INHERIT_FD;
-        stdioBuf[index].data.fd = o.m_data.stdio.fd;
-        break;
-      }
-      case Option::kStdioInheritPipe: {
-        size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) {
-          stdioBuf.resize(index + 1);
-        }
-        stdioBuf[index].flags = UV_INHERIT_STREAM;
-        stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
-        break;
-      }
-      case Option::kStdioCreatePipe: {
-        size_t index = o.m_data.stdio.index;
-        if (index >= stdioBuf.size()) {
-          stdioBuf.resize(index + 1);
-        }
-        stdioBuf[index].flags =
-            static_cast<uv_stdio_flags>(UV_CREATE_PIPE | o.m_data.stdio.flags);
-        stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
-        break;
-      }
-      default:
-        break;
-    }
-  }
-
-  if (argsBuf.empty()) {
-    argsBuf.push_back(const_cast<char*>(coptions.file));
-  }
-  argsBuf.push_back(nullptr);
-  coptions.args = argsBuf.data();
-
-  if (envBuf.empty()) {
-    coptions.env = nullptr;
-  } else {
-    envBuf.push_back(nullptr);
-    coptions.env = envBuf.data();
-  }
-
-  coptions.stdio_count = stdioBuf.size();
-  coptions.stdio = static_cast<uv_stdio_container_t*>(stdioBuf.data());
-
-  auto h = std::make_shared<Process>(private_init{});
-  int err = uv_spawn(loop.GetRaw(), h->GetRaw(), &coptions);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Signal.cpp b/wpiutil/src/main/native/cpp/uv/Signal.cpp
deleted file mode 100644
index 81d7c3e..0000000
--- a/wpiutil/src/main/native/cpp/uv/Signal.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Signal.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Signal> Signal::Create(Loop& loop) {
-  auto h = std::make_shared<Signal>(private_init{});
-  int err = uv_signal_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Signal::Start(int signum) {
-  Invoke(
-      &uv_signal_start, GetRaw(),
-      [](uv_signal_t* handle, int signum) {
-        Signal& h = *static_cast<Signal*>(handle->data);
-        h.signal(signum);
-      },
-      signum);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Stream.cpp b/wpiutil/src/main/native/cpp/uv/Stream.cpp
deleted file mode 100644
index a37750b..0000000
--- a/wpiutil/src/main/native/cpp/uv/Stream.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Stream.h"
-
-#include "wpi/SmallVector.h"
-
-using namespace wpi;
-using namespace wpi::uv;
-
-namespace {
-class CallbackWriteReq : public WriteReq {
- public:
-  CallbackWriteReq(span<const Buffer> bufs,
-                   std::function<void(span<Buffer>, Error)> callback)
-      : m_bufs{bufs.begin(), bufs.end()} {
-    finish.connect(
-        [this, f = std::move(callback)](Error err) { f(m_bufs, err); });
-  }
-
- private:
-  SmallVector<Buffer, 4> m_bufs;
-};
-}  // namespace
-
-namespace wpi::uv {
-
-ShutdownReq::ShutdownReq() {
-  error = [this](Error err) { GetStream().error(err); };
-}
-
-WriteReq::WriteReq() {
-  error = [this](Error err) { GetStream().error(err); };
-}
-
-void Stream::Shutdown(const std::shared_ptr<ShutdownReq>& req) {
-  if (Invoke(&uv_shutdown, req->GetRaw(), GetRawStream(),
-             [](uv_shutdown_t* req, int status) {
-               auto& h = *static_cast<ShutdownReq*>(req->data);
-               if (status < 0) {
-                 h.ReportError(status);
-               } else {
-                 h.complete();
-               }
-               h.Release();  // this is always a one-shot
-             })) {
-    req->Keep();
-  }
-}
-
-void Stream::Shutdown(std::function<void()> callback) {
-  auto req = std::make_shared<ShutdownReq>();
-  if (callback) {
-    req->complete.connect(std::move(callback));
-  }
-  Shutdown(req);
-}
-
-void Stream::StartRead() {
-  Invoke(&uv_read_start, GetRawStream(), &Handle::AllocBuf,
-         [](uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
-           auto& h = *static_cast<Stream*>(stream->data);
-           Buffer data = *buf;
-
-           // nread=0 is simply ignored
-           if (nread == UV_EOF) {
-             h.end();
-           } else if (nread > 0) {
-             h.data(data, static_cast<size_t>(nread));
-           } else if (nread < 0) {
-             h.ReportError(nread);
-           }
-
-           // free the buffer
-           h.FreeBuf(data);
-         });
-}
-
-void Stream::Write(span<const Buffer> bufs,
-                   const std::shared_ptr<WriteReq>& req) {
-  if (Invoke(&uv_write, req->GetRaw(), GetRawStream(), bufs.data(), bufs.size(),
-             [](uv_write_t* r, int status) {
-               auto& h = *static_cast<WriteReq*>(r->data);
-               if (status < 0) {
-                 h.ReportError(status);
-               }
-               h.finish(Error(status));
-               h.Release();  // this is always a one-shot
-             })) {
-    req->Keep();
-  }
-}
-
-void Stream::Write(span<const Buffer> bufs,
-                   std::function<void(span<Buffer>, Error)> callback) {
-  Write(bufs, std::make_shared<CallbackWriteReq>(bufs, std::move(callback)));
-}
-
-int Stream::TryWrite(span<const Buffer> bufs) {
-  int val = uv_try_write(GetRawStream(), bufs.data(), bufs.size());
-  if (val < 0) {
-    this->ReportError(val);
-    return 0;
-  }
-  return val;
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Tcp.cpp b/wpiutil/src/main/native/cpp/uv/Tcp.cpp
deleted file mode 100644
index 6f92557..0000000
--- a/wpiutil/src/main/native/cpp/uv/Tcp.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Tcp.h"
-
-#include <cstring>
-
-#include "wpi/uv/util.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Tcp> Tcp::Create(Loop& loop, unsigned int flags) {
-  auto h = std::make_shared<Tcp>(private_init{});
-  int err = uv_tcp_init_ex(loop.GetRaw(), h->GetRaw(), flags);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Tcp::Reuse(std::function<void()> callback, unsigned int flags) {
-  if (IsClosing()) {
-    return;
-  }
-  if (!m_reuseData) {
-    m_reuseData = std::make_unique<ReuseData>();
-  }
-  m_reuseData->callback = std::move(callback);
-  m_reuseData->flags = flags;
-  uv_close(GetRawHandle(), [](uv_handle_t* handle) {
-    Tcp& h = *static_cast<Tcp*>(handle->data);
-    if (!h.m_reuseData) {
-      return;  // just in case
-    }
-    auto data = std::move(h.m_reuseData);
-    int err = uv_tcp_init_ex(h.GetLoopRef().GetRaw(), h.GetRaw(), data->flags);
-    if (err < 0) {
-      h.ReportError(err);
-      return;
-    }
-    data->callback();
-  });
-}
-
-std::shared_ptr<Tcp> Tcp::Accept() {
-  auto client = Create(GetLoopRef());
-  if (!client) {
-    return nullptr;
-  }
-  if (!Accept(client)) {
-    client->Release();
-    return nullptr;
-  }
-  return client;
-}
-
-Tcp* Tcp::DoAccept() {
-  return Accept().get();
-}
-
-void Tcp::Bind(std::string_view ip, unsigned int port, unsigned int flags) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void Tcp::Bind6(std::string_view ip, unsigned int port, unsigned int flags) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-sockaddr_storage Tcp::GetSock() {
-  sockaddr_storage name;
-  int len = sizeof(name);
-  if (!Invoke(&uv_tcp_getsockname, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len)) {
-    std::memset(&name, 0, sizeof(name));
-  }
-  return name;
-}
-
-sockaddr_storage Tcp::GetPeer() {
-  sockaddr_storage name;
-  int len = sizeof(name);
-  if (!Invoke(&uv_tcp_getpeername, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len)) {
-    std::memset(&name, 0, sizeof(name));
-  }
-  return name;
-}
-
-void Tcp::Connect(const sockaddr& addr,
-                  const std::shared_ptr<TcpConnectReq>& req) {
-  if (Invoke(&uv_tcp_connect, req->GetRaw(), GetRaw(), &addr,
-             [](uv_connect_t* req, int status) {
-               auto& h = *static_cast<TcpConnectReq*>(req->data);
-               if (status < 0) {
-                 h.ReportError(status);
-               } else {
-                 h.connected();
-               }
-               h.Release();  // this is always a one-shot
-             })) {
-    req->Keep();
-  }
-}
-
-void Tcp::Connect(const sockaddr& addr, std::function<void()> callback) {
-  auto req = std::make_shared<TcpConnectReq>();
-  req->connected.connect(std::move(callback));
-  Connect(addr, req);
-}
-
-void Tcp::Connect(std::string_view ip, unsigned int port,
-                  const std::shared_ptr<TcpConnectReq>& req) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), req);
-  }
-}
-
-void Tcp::Connect(std::string_view ip, unsigned int port,
-                  std::function<void()> callback) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
-  }
-}
-
-void Tcp::Connect6(std::string_view ip, unsigned int port,
-                   const std::shared_ptr<TcpConnectReq>& req) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), req);
-  }
-}
-
-void Tcp::Connect6(std::string_view ip, unsigned int port,
-                   std::function<void()> callback) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
-  }
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Timer.cpp b/wpiutil/src/main/native/cpp/uv/Timer.cpp
deleted file mode 100644
index 33fd851..0000000
--- a/wpiutil/src/main/native/cpp/uv/Timer.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Timer.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Timer> Timer::Create(Loop& loop) {
-  auto h = std::make_shared<Timer>(private_init{});
-  int err = uv_timer_init(loop.GetRaw(), h->GetRaw());
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Timer::SingleShot(Loop& loop, Time timeout, std::function<void()> func) {
-  auto h = Create(loop);
-  if (!h) {
-    return;
-  }
-  h->timeout.connect([theTimer = h.get(), f = std::move(func)]() {
-    f();
-    theTimer->Close();
-  });
-  h->Start(timeout);
-}
-
-void Timer::Start(Time timeout, Time repeat) {
-  Invoke(
-      &uv_timer_start, GetRaw(),
-      [](uv_timer_t* handle) {
-        Timer& h = *static_cast<Timer*>(handle->data);
-        h.timeout();
-      },
-      timeout.count(), repeat.count());
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Tty.cpp b/wpiutil/src/main/native/cpp/uv/Tty.cpp
deleted file mode 100644
index 4531ded..0000000
--- a/wpiutil/src/main/native/cpp/uv/Tty.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Tty.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-std::shared_ptr<Tty> Tty::Create(Loop& loop, uv_file fd, bool readable) {
-  auto h = std::make_shared<Tty>(private_init{});
-  int err = uv_tty_init(loop.GetRaw(), h->GetRaw(), fd, readable ? 1 : 0);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Udp.cpp b/wpiutil/src/main/native/cpp/uv/Udp.cpp
deleted file mode 100644
index bea2b57..0000000
--- a/wpiutil/src/main/native/cpp/uv/Udp.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Udp.h"
-
-#include <cstring>
-
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/uv/util.h"
-
-namespace {
-
-using namespace wpi;
-using namespace wpi::uv;
-
-class CallbackUdpSendReq : public UdpSendReq {
- public:
-  CallbackUdpSendReq(span<const Buffer> bufs,
-                     std::function<void(span<Buffer>, Error)> callback)
-      : m_bufs{bufs.begin(), bufs.end()} {
-    complete.connect(
-        [this, f = std::move(callback)](Error err) { f(m_bufs, err); });
-  }
-
- private:
-  SmallVector<Buffer, 4> m_bufs;
-};
-
-}  // namespace
-
-namespace wpi::uv {
-
-UdpSendReq::UdpSendReq() {
-  error = [this](Error err) { GetUdp().error(err); };
-}
-
-std::shared_ptr<Udp> Udp::Create(Loop& loop, unsigned int flags) {
-  auto h = std::make_shared<Udp>(private_init{});
-  int err = uv_udp_init_ex(loop.GetRaw(), h->GetRaw(), flags);
-  if (err < 0) {
-    loop.ReportError(err);
-    return nullptr;
-  }
-  h->Keep();
-  return h;
-}
-
-void Udp::Bind(std::string_view ip, unsigned int port, unsigned int flags) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void Udp::Bind6(std::string_view ip, unsigned int port, unsigned int flags) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-}
-
-void Udp::Connect(std::string_view ip, unsigned int port) {
-  sockaddr_in addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr));
-  }
-}
-
-void Udp::Connect6(std::string_view ip, unsigned int port) {
-  sockaddr_in6 addr;
-  int err = NameToAddr(ip, port, &addr);
-  if (err < 0) {
-    ReportError(err);
-  } else {
-    Connect(reinterpret_cast<const sockaddr&>(addr));
-  }
-}
-
-sockaddr_storage Udp::GetPeer() {
-  sockaddr_storage name;
-  int len = sizeof(name);
-  if (!Invoke(&uv_udp_getpeername, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len)) {
-    std::memset(&name, 0, sizeof(name));
-  }
-  return name;
-}
-
-sockaddr_storage Udp::GetSock() {
-  sockaddr_storage name;
-  int len = sizeof(name);
-  if (!Invoke(&uv_udp_getsockname, GetRaw(), reinterpret_cast<sockaddr*>(&name),
-              &len)) {
-    std::memset(&name, 0, sizeof(name));
-  }
-  return name;
-}
-
-void Udp::SetMembership(std::string_view multicastAddr,
-                        std::string_view interfaceAddr,
-                        uv_membership membership) {
-  SmallString<128> multicastAddrBuf{multicastAddr};
-  SmallString<128> interfaceAddrBuf{interfaceAddr};
-  Invoke(&uv_udp_set_membership, GetRaw(), multicastAddrBuf.c_str(),
-         interfaceAddrBuf.c_str(), membership);
-}
-
-void Udp::SetMulticastInterface(std::string_view interfaceAddr) {
-  SmallString<128> interfaceAddrBuf{interfaceAddr};
-  Invoke(&uv_udp_set_multicast_interface, GetRaw(), interfaceAddrBuf.c_str());
-}
-
-void Udp::Send(const sockaddr& addr, span<const Buffer> bufs,
-               const std::shared_ptr<UdpSendReq>& req) {
-  if (Invoke(&uv_udp_send, req->GetRaw(), GetRaw(), bufs.data(), bufs.size(),
-             &addr, [](uv_udp_send_t* r, int status) {
-               auto& h = *static_cast<UdpSendReq*>(r->data);
-               if (status < 0) {
-                 h.ReportError(status);
-               }
-               h.complete(Error(status));
-               h.Release();  // this is always a one-shot
-             })) {
-    req->Keep();
-  }
-}
-
-void Udp::Send(const sockaddr& addr, span<const Buffer> bufs,
-               std::function<void(span<Buffer>, Error)> callback) {
-  Send(addr, bufs,
-       std::make_shared<CallbackUdpSendReq>(bufs, std::move(callback)));
-}
-
-void Udp::Send(span<const Buffer> bufs,
-               const std::shared_ptr<UdpSendReq>& req) {
-  if (Invoke(&uv_udp_send, req->GetRaw(), GetRaw(), bufs.data(), bufs.size(),
-             nullptr, [](uv_udp_send_t* r, int status) {
-               auto& h = *static_cast<UdpSendReq*>(r->data);
-               if (status < 0) {
-                 h.ReportError(status);
-               }
-               h.complete(Error(status));
-               h.Release();  // this is always a one-shot
-             })) {
-    req->Keep();
-  }
-}
-
-void Udp::Send(span<const Buffer> bufs,
-               std::function<void(span<Buffer>, Error)> callback) {
-  Send(bufs, std::make_shared<CallbackUdpSendReq>(bufs, std::move(callback)));
-}
-
-void Udp::StartRecv() {
-  Invoke(&uv_udp_recv_start, GetRaw(), &AllocBuf,
-         [](uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf,
-            const sockaddr* addr, unsigned flags) {
-           auto& h = *static_cast<Udp*>(handle->data);
-           Buffer data = *buf;
-
-           // nread=0 is simply ignored
-           if (nread > 0) {
-             h.received(data, static_cast<size_t>(nread), *addr, flags);
-           } else if (nread < 0) {
-             h.ReportError(nread);
-           }
-
-           // free the buffer
-           h.FreeBuf(data);
-         });
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/cpp/uv/Work.cpp b/wpiutil/src/main/native/cpp/uv/Work.cpp
deleted file mode 100644
index 0fc254e..0000000
--- a/wpiutil/src/main/native/cpp/uv/Work.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Work.h"
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-WorkReq::WorkReq() {
-  error = [this](Error err) { GetLoop().error(err); };
-}
-
-void QueueWork(Loop& loop, const std::shared_ptr<WorkReq>& req) {
-  int err = uv_queue_work(
-      loop.GetRaw(), req->GetRaw(),
-      [](uv_work_t* req) {
-        auto& h = *static_cast<WorkReq*>(req->data);
-        h.work();
-      },
-      [](uv_work_t* req, int status) {
-        auto& h = *static_cast<WorkReq*>(req->data);
-        if (status < 0) {
-          h.ReportError(status);
-        } else {
-          h.afterWork();
-        }
-        h.Release();  // this is always a one-shot
-      });
-  if (err < 0) {
-    loop.ReportError(err);
-  } else {
-    req->Keep();
-  }
-}
-
-void QueueWork(Loop& loop, std::function<void()> work,
-               std::function<void()> afterWork) {
-  auto req = std::make_shared<WorkReq>();
-  if (work) {
-    req->work.connect(std::move(work));
-  }
-  if (afterWork) {
-    req->afterWork.connect(std::move(afterWork));
-  }
-  QueueWork(loop, req);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/format-inl.h b/wpiutil/src/main/native/fmtlib/include/fmt/format-inl.h
deleted file mode 100644
index cc89abd..0000000
--- a/wpiutil/src/main/native/fmtlib/include/fmt/format-inl.h
+++ /dev/null
@@ -1,2642 +0,0 @@
-// 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 <cctype>
-#include <cerrno>  // errno
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstring>  // std::memmove
-#include <cwchar>
-#include <exception>
-
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-#  include <locale>
-#endif
-
-#ifdef _WIN32
-#  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));
-}
-
-#ifndef _MSC_VER
-#  define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-#  define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
-                                string_view message) FMT_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)
-    format_to(it, FMT_STRING("{}{}"), message, SEP);
-  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) FMT_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 size, size_t count,
-                         FILE* stream) {
-  std::fwrite(ptr, size, count, stream);
-}
-
-#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> Locale locale_ref::get() const {
-  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 Char decimal_point_impl(locale_ref loc) {
-  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
-}  // namespace detail
-
-#if !FMT_MSC_VER
-FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
-#endif
-
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
-                                         format_args args) {
-  auto ec = std::error_code(error_code, std::generic_category());
-  return std::system_error(ec, vformat(format_str, args));
-}
-
-namespace detail {
-
-template <> FMT_FUNC int count_digits<4>(detail::fallback_uintptr n) {
-  // fallback_uintptr is always stored in little endian.
-  int i = static_cast<int>(sizeof(void*)) - 1;
-  while (i > 0 && n.value[i] == 0) --i;
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
-}
-
-// log10(2) = 0x0.4d104d427de7fbcc...
-static constexpr uint64_t log10_2_significand = 0x4d104d427de7fbcc;
-
-template <typename T = void> struct basic_impl_data {
-  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
-  // These are generated by support/compute-powers.py.
-  static constexpr uint64_t pow10_significands[87] = {
-      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
-      0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
-      0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
-      0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
-      0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
-      0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
-      0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
-      0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
-      0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
-      0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
-      0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
-      0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
-      0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
-      0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
-      0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
-      0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
-      0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
-      0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
-      0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
-      0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
-      0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
-      0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
-  };
-
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wnarrowing"
-#endif
-  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
-  // to significands above.
-  static constexpr int16_t pow10_exponents[87] = {
-      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-      -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
-      -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
-      -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
-      -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
-      242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
-      534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
-      827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
-#  pragma GCC diagnostic pop
-#endif
-
-  static constexpr uint64_t power_of_10_64[20] = {
-      1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL),
-      10000000000000000000ULL};
-};
-
-// This is a struct rather than an alias to avoid shadowing warnings in gcc.
-struct impl_data : basic_impl_data<> {};
-
-#if __cplusplus < 201703L
-template <typename T>
-constexpr uint64_t basic_impl_data<T>::pow10_significands[];
-template <typename T> constexpr int16_t basic_impl_data<T>::pow10_exponents[];
-template <typename T> constexpr uint64_t basic_impl_data<T>::power_of_10_64[];
-#endif
-
-template <typename T> struct bits {
-  static FMT_CONSTEXPR_DECL const int value =
-      static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
-};
-
-// Returns the number of significand bits in Float excluding the implicit bit.
-template <typename Float> constexpr int num_significand_bits() {
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  return std::numeric_limits<Float>::digits - 1;
-}
-
-// A floating-point number f * pow(2, e).
-struct fp {
-  uint64_t f;
-  int e;
-
-  static constexpr const int num_significand_bits = bits<decltype(f)>::value;
-
-  constexpr fp() : f(0), e(0) {}
-  constexpr fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
-
-  // Constructs fp from an IEEE754 floating-point number. It is a template to
-  // prevent compile errors on systems where n is not IEEE754.
-  template <typename Float> explicit FMT_CONSTEXPR fp(Float n) { assign(n); }
-
-  template <typename Float>
-  using is_supported = bool_constant<sizeof(Float) == sizeof(uint64_t) ||
-                                     sizeof(Float) == sizeof(uint32_t)>;
-
-  // Assigns d to this and return true iff predecessor is closer than successor.
-  template <typename Float, FMT_ENABLE_IF(is_supported<Float>::value)>
-  FMT_CONSTEXPR bool assign(Float n) {
-    // Assume float is in the format [sign][exponent][significand].
-    const int num_float_significand_bits =
-        detail::num_significand_bits<Float>();
-    const uint64_t implicit_bit = 1ULL << num_float_significand_bits;
-    const uint64_t significand_mask = implicit_bit - 1;
-    constexpr bool is_double = sizeof(Float) == sizeof(uint64_t);
-    auto u = bit_cast<conditional_t<is_double, uint64_t, uint32_t>>(n);
-    f = u & significand_mask;
-    const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
-    int biased_e =
-        static_cast<int>((u & exponent_mask) >> 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).
-    bool is_predecessor_closer = f == 0 && biased_e > 1;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    const int exponent_bias = std::numeric_limits<Float>::max_exponent - 1;
-    e = biased_e - exponent_bias - num_float_significand_bits;
-    return is_predecessor_closer;
-  }
-
-  template <typename Float, FMT_ENABLE_IF(!is_supported<Float>::value)>
-  bool assign(Float) {
-    FMT_ASSERT(false, "");
-    return false;
-  }
-};
-
-// Normalizes the value converted from double and multiplied by (1 << SHIFT).
-template <int SHIFT = 0> FMT_CONSTEXPR fp normalize(fp value) {
-  // Handle subnormals.
-  const uint64_t implicit_bit = 1ULL << 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 =
-      fp::num_significand_bits - num_significand_bits<double>() - SHIFT - 1;
-  value.f <<= offset;
-  value.e -= offset;
-  return value;
-}
-
-inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
-
-// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
-FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
-#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 fp operator*(fp x, fp y) {
-  return {multiply(x.f, y.f), x.e + y.e + 64};
-}
-
-// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
-// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
-FMT_CONSTEXPR inline fp get_cached_power(int min_exponent,
-                                         int& pow10_exponent) {
-  const int shift = 32;
-  const auto significand = static_cast<int64_t>(log10_2_significand);
-  int index = static_cast<int>(
-      ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) +
-       ((int64_t(1) << shift) - 1))  // ceil
-      >> 32                          // arithmetic shift
-  );
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between 2 consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return {impl_data::pow10_significands[index],
-          impl_data::pow10_exponents[index]};
-}
-
-// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
-// is not available.
-struct accumulator {
-  uint64_t lower;
-  uint64_t upper;
-
-  constexpr accumulator() : lower(0), upper(0) {}
-  constexpr explicit operator uint32_t() const {
-    return static_cast<uint32_t>(lower);
-  }
-
-  FMT_CONSTEXPR void operator+=(uint64_t n) {
-    lower += n;
-    if (lower < n) ++upper;
-  }
-  FMT_CONSTEXPR void operator>>=(int shift) {
-    FMT_ASSERT(shift == 32, "");
-    (void)shift;
-    lower = (upper << 32) | (lower >> 32);
-    upper >>= 32;
-  }
-};
-
-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 bigit operator[](int index) const {
-    return bigits_[to_unsigned(index)];
-  }
-  FMT_CONSTEXPR20 bigit& operator[](int index) {
-    return bigits_[to_unsigned(index)];
-  }
-
-  static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
-
-  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);
-  }
-
-  FMT_CONSTEXPR20 void multiply(uint64_t value) {
-    const bigit mask = ~bigit(0);
-    const double_bigit lower = value & mask;
-    const double_bigit upper = value >> bigit_bits;
-    double_bigit carry = 0;
-    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
-      double_bigit result = bigits_[i] * lower + (carry & mask);
-      carry =
-          bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
-      bigits_[i] = static_cast<bigit>(result);
-    }
-    while (carry != 0) {
-      bigits_.push_back(carry & mask);
-      carry >>= bigit_bits;
-    }
-  }
-
- public:
-  FMT_CONSTEXPR20 bigint() : exp_(0) {}
-  explicit bigint(uint64_t n) { assign(n); }
-  FMT_CONSTEXPR20 ~bigint() {
-    FMT_ASSERT(bigits_.capacity() <= bigits_capacity, "");
-  }
-
-  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();
-    std::copy(data, data + size, make_checked(bigits_.data(), size));
-    exp_ = other.exp_;
-  }
-
-  FMT_CONSTEXPR20 void assign(uint64_t n) {
-    size_t num_bigits = 0;
-    do {
-      bigits_[num_bigits++] = n & ~bigit(0);
-      n >>= bigit_bits;
-    } while (n != 0);
-    bigits_.resize(num_bigits);
-    exp_ = 0;
-  }
-
-  FMT_CONSTEXPR20 int num_bigits() const {
-    return static_cast<int>(bigits_.size()) + exp_;
-  }
-
-  FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
-    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 bigint& operator*=(Int value) {
-    FMT_ASSERT(value > 0, "");
-    multiply(uint32_or_64_or_128_t<Int>(value));
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
-    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 int add_compare(const bigint& lhs1, const bigint& lhs2,
-                                         const bigint& rhs) {
-    int max_lhs_bigits = (std::max)(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 = (std::min)((std::min)(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 assign(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.
-    assign(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));
-    using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
-    auto sum = accumulator_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 >>= bits<bigit>::value;  // 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 >>= bits<bigit>::value;
-    }
-    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, 0);
-    exp_ -= exp_difference;
-  }
-
-  // Divides this bignum by divisor, assigning the remainder to this and
-  // returning the quotient.
-  FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
-    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;
-  }
-};
-
-enum class round_direction { unknown, up, down };
-
-// Given the divisor (normally a power of 10), the remainder = v % divisor for
-// some number v and the error, returns whether v should be rounded up, down, or
-// whether the rounding direction can't be determined due to error.
-// error should be less than divisor / 2.
-FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor,
-                                                         uint64_t remainder,
-                                                         uint64_t error) {
-  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
-  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
-  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
-  // Round down if (remainder + error) * 2 <= divisor.
-  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
-    return round_direction::down;
-  // Round up if (remainder - error) * 2 >= divisor.
-  if (remainder >= error &&
-      remainder - error >= divisor - (remainder - error)) {
-    return round_direction::up;
-  }
-  return round_direction::unknown;
-}
-
-namespace digits {
-enum result {
-  more,  // Generate more digits.
-  done,  // Done generating digits.
-  error  // Digit generation cancelled due to an error.
-};
-}
-
-struct gen_digits_handler {
-  char* buf;
-  int size;
-  int precision;
-  int exp10;
-  bool fixed;
-
-  FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor,
-                                        uint64_t remainder, uint64_t error,
-                                        bool integral) {
-    FMT_ASSERT(remainder < divisor, "");
-    buf[size++] = digit;
-    if (!integral && error >= remainder) return digits::error;
-    if (size < precision) return digits::more;
-    if (!integral) {
-      // Check if error * 2 < divisor with overflow prevention.
-      // The check is not needed for the integral part because error = 1
-      // and divisor > (1 << 32) there.
-      if (error >= divisor || error >= divisor - error) return digits::error;
-    } else {
-      FMT_ASSERT(error == 1 && divisor > 2, "");
-    }
-    auto dir = get_round_direction(divisor, remainder, error);
-    if (dir != round_direction::up)
-      return dir == round_direction::down ? digits::done : digits::error;
-    ++buf[size - 1];
-    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
-      buf[i] = '0';
-      ++buf[i - 1];
-    }
-    if (buf[0] > '9') {
-      buf[0] = '1';
-      if (fixed)
-        buf[size++] = '0';
-      else
-        ++exp10;
-    }
-    return digits::done;
-  }
-};
-
-// Generates output using the Grisu digit-gen algorithm.
-// error: the size of the region (lower, upper) outside of which numbers
-// definitely do not round to value (Delta in Grisu3).
-FMT_INLINE FMT_CONSTEXPR20 digits::result grisu_gen_digits(
-    fp value, uint64_t error, int& exp, gen_digits_handler& handler) {
-  const fp one(1ULL << -value.e, value.e);
-  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
-  // zero because it contains a product of two 64-bit numbers with MSB set (due
-  // to normalization) - 1, shifted right by at most 60 bits.
-  auto integral = static_cast<uint32_t>(value.f >> -one.e);
-  FMT_ASSERT(integral != 0, "");
-  FMT_ASSERT(integral == value.f >> -one.e, "");
-  // The fractional part of scaled value (p2 in Grisu) c = value % one.
-  uint64_t fractional = value.f & (one.f - 1);
-  exp = count_digits(integral);  // kappa in Grisu.
-  // Non-fixed formats require at least one digit and no precision adjustment.
-  if (handler.fixed) {
-    // Adjust fixed precision by exponent because it is relative to decimal
-    // point.
-    int precision_offset = exp + handler.exp10;
-    if (precision_offset > 0 &&
-        handler.precision > max_value<int>() - precision_offset) {
-      FMT_THROW(format_error("number is too big"));
-    }
-    handler.precision += precision_offset;
-    // Check if precision is satisfied just by leading zeros, e.g.
-    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
-    if (handler.precision <= 0) {
-      if (handler.precision < 0) return digits::done;
-      // Divide by 10 to prevent overflow.
-      uint64_t divisor = impl_data::power_of_10_64[exp - 1] << -one.e;
-      auto dir = get_round_direction(divisor, value.f / 10, error * 10);
-      if (dir == round_direction::unknown) return digits::error;
-      handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0';
-      return digits::done;
-    }
-  }
-  // Generate digits for the integral part. This can produce up to 10 digits.
-  do {
-    uint32_t digit = 0;
-    auto divmod_integral = [&](uint32_t divisor) {
-      digit = integral / divisor;
-      integral %= divisor;
-    };
-    // This optimization by Milo Yip reduces the number of integer divisions by
-    // one per iteration.
-    switch (exp) {
-    case 10:
-      divmod_integral(1000000000);
-      break;
-    case 9:
-      divmod_integral(100000000);
-      break;
-    case 8:
-      divmod_integral(10000000);
-      break;
-    case 7:
-      divmod_integral(1000000);
-      break;
-    case 6:
-      divmod_integral(100000);
-      break;
-    case 5:
-      divmod_integral(10000);
-      break;
-    case 4:
-      divmod_integral(1000);
-      break;
-    case 3:
-      divmod_integral(100);
-      break;
-    case 2:
-      divmod_integral(10);
-      break;
-    case 1:
-      digit = integral;
-      integral = 0;
-      break;
-    default:
-      FMT_ASSERT(false, "invalid number of digits");
-    }
-    --exp;
-    auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
-    auto result = handler.on_digit(static_cast<char>('0' + digit),
-                                   impl_data::power_of_10_64[exp] << -one.e,
-                                   remainder, error, true);
-    if (result != digits::more) return result;
-  } while (exp > 0);
-  // Generate digits for the fractional part.
-  for (;;) {
-    fractional *= 10;
-    error *= 10;
-    char digit = static_cast<char>('0' + (fractional >> -one.e));
-    fractional &= one.f - 1;
-    --exp;
-    auto result = handler.on_digit(digit, one.f, fractional, error, false);
-    if (result != digits::more) return result;
-  }
-}
-
-// A 128-bit integer type used internally,
-struct uint128_wrapper {
-  uint128_wrapper() = default;
-
-#if FMT_USE_INT128
-  uint128_t internal_;
-
-  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
-      : internal_{static_cast<uint128_t>(low) |
-                  (static_cast<uint128_t>(high) << 64)} {}
-
-  constexpr uint128_wrapper(uint128_t u) : internal_{u} {}
-
-  constexpr uint64_t high() const FMT_NOEXCEPT {
-    return uint64_t(internal_ >> 64);
-  }
-  constexpr uint64_t low() const FMT_NOEXCEPT { return uint64_t(internal_); }
-
-  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
-    internal_ += n;
-    return *this;
-  }
-#else
-  uint64_t high_;
-  uint64_t low_;
-
-  constexpr uint128_wrapper(uint64_t high, uint64_t low) FMT_NOEXCEPT
-      : high_{high},
-        low_{low} {}
-
-  constexpr uint64_t high() const FMT_NOEXCEPT { return high_; }
-  constexpr uint64_t low() const FMT_NOEXCEPT { return low_; }
-
-  uint128_wrapper& operator+=(uint64_t n) FMT_NOEXCEPT {
-#  if defined(_MSC_VER) && defined(_M_X64)
-    unsigned char carry = _addcarry_u64(0, low_, n, &low_);
-    _addcarry_u64(carry, high_, 0, &high_);
-    return *this;
-#  else
-    uint64_t sum = low_ + n;
-    high_ += (sum < low_ ? 1 : 0);
-    low_ = sum;
-    return *this;
-#  endif
-  }
-#endif
-};
-
-// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
-namespace dragonbox {
-// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline uint128_wrapper umul128(uint64_t x, uint64_t y) FMT_NOEXCEPT {
-#if FMT_USE_INT128
-  return static_cast<uint128_t>(x) * static_cast<uint128_t>(y);
-#elif defined(_MSC_VER) && defined(_M_X64)
-  uint128_wrapper result;
-  result.low_ = _umul128(x, y, &result.high_);
-  return result;
-#else
-  const uint64_t mask = (uint64_t(1) << 32) - uint64_t(1);
-
-  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
-}
-
-// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) FMT_NOEXCEPT {
-#if FMT_USE_INT128
-  auto p = static_cast<uint128_t>(x) * static_cast<uint128_t>(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 64 bits of multiplication of a 64-bit unsigned integer and a
-// 128-bit unsigned integer.
-inline uint64_t umul192_upper64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
-  uint128_wrapper g0 = umul128(x, y.high());
-  g0 += umul128_upper64(x, y.low());
-  return g0.high();
-}
-
-// Computes upper 32 bits of multiplication of a 32-bit unsigned integer and a
-// 64-bit unsigned integer.
-inline uint32_t umul96_upper32(uint32_t x, uint64_t y) FMT_NOEXCEPT {
-  return static_cast<uint32_t>(umul128_upper64(x, y));
-}
-
-// Computes middle 64 bits of multiplication of a 64-bit unsigned integer and a
-// 128-bit unsigned integer.
-inline uint64_t umul192_middle64(uint64_t x, uint128_wrapper y) FMT_NOEXCEPT {
-  uint64_t g01 = x * y.high();
-  uint64_t g10 = umul128_upper64(x, y.low());
-  return g01 + g10;
-}
-
-// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
-// 64-bit unsigned integer.
-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) FMT_NOEXCEPT {
-  return x * y;
-}
-
-// Computes floor(log10(pow(2, e))) for e in [-1700, 1700] using the method from
-// https://fmt.dev/papers/Grisu-Exact.pdf#page=5, section 3.4.
-inline int floor_log10_pow2(int e) FMT_NOEXCEPT {
-  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
-  const int shift = 22;
-  return (e * static_cast<int>(log10_2_significand >> (64 - shift))) >> shift;
-}
-
-// Various fast log computations.
-inline int floor_log2_pow10(int e) FMT_NOEXCEPT {
-  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
-  const uint64_t log2_10_integer_part = 3;
-  const uint64_t log2_10_fractional_digits = 0x5269e12f346e2bf9;
-  const int shift_amount = 19;
-  return (e * static_cast<int>(
-                  (log2_10_integer_part << shift_amount) |
-                  (log2_10_fractional_digits >> (64 - shift_amount)))) >>
-         shift_amount;
-}
-inline int floor_log10_pow2_minus_log10_4_over_3(int e) FMT_NOEXCEPT {
-  FMT_ASSERT(e <= 1700 && e >= -1700, "too large exponent");
-  const uint64_t log10_4_over_3_fractional_digits = 0x1ffbfc2bbc780375;
-  const int shift_amount = 22;
-  return (e * static_cast<int>(log10_2_significand >> (64 - shift_amount)) -
-          static_cast<int>(log10_4_over_3_fractional_digits >>
-                           (64 - shift_amount))) >>
-         shift_amount;
-}
-
-// Returns true iff x is divisible by pow(2, exp).
-inline bool divisible_by_power_of_2(uint32_t x, int exp) FMT_NOEXCEPT {
-  FMT_ASSERT(exp >= 1, "");
-  FMT_ASSERT(x != 0, "");
-#ifdef FMT_BUILTIN_CTZ
-  return FMT_BUILTIN_CTZ(x) >= exp;
-#else
-  return exp < num_bits<uint32_t>() && x == ((x >> exp) << exp);
-#endif
-}
-inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT {
-  FMT_ASSERT(exp >= 1, "");
-  FMT_ASSERT(x != 0, "");
-#ifdef FMT_BUILTIN_CTZLL
-  return FMT_BUILTIN_CTZLL(x) >= exp;
-#else
-  return exp < num_bits<uint64_t>() && x == ((x >> exp) << exp);
-#endif
-}
-
-// Table entry type for divisibility test.
-template <typename T> struct divtest_table_entry {
-  T mod_inv;
-  T max_quotient;
-};
-
-// Returns true iff x is divisible by pow(5, exp).
-inline bool divisible_by_power_of_5(uint32_t x, int exp) FMT_NOEXCEPT {
-  FMT_ASSERT(exp <= 10, "too large exponent");
-  static constexpr const divtest_table_entry<uint32_t> divtest_table[] = {
-      {0x00000001, 0xffffffff}, {0xcccccccd, 0x33333333},
-      {0xc28f5c29, 0x0a3d70a3}, {0x26e978d5, 0x020c49ba},
-      {0x3afb7e91, 0x0068db8b}, {0x0bcbe61d, 0x0014f8b5},
-      {0x68c26139, 0x000431bd}, {0xae8d46a5, 0x0000d6bf},
-      {0x22e90e21, 0x00002af3}, {0x3a2e9c6d, 0x00000897},
-      {0x3ed61f49, 0x000001b7}};
-  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
-}
-inline bool divisible_by_power_of_5(uint64_t x, int exp) FMT_NOEXCEPT {
-  FMT_ASSERT(exp <= 23, "too large exponent");
-  static constexpr const divtest_table_entry<uint64_t> divtest_table[] = {
-      {0x0000000000000001, 0xffffffffffffffff},
-      {0xcccccccccccccccd, 0x3333333333333333},
-      {0x8f5c28f5c28f5c29, 0x0a3d70a3d70a3d70},
-      {0x1cac083126e978d5, 0x020c49ba5e353f7c},
-      {0xd288ce703afb7e91, 0x0068db8bac710cb2},
-      {0x5d4e8fb00bcbe61d, 0x0014f8b588e368f0},
-      {0x790fb65668c26139, 0x000431bde82d7b63},
-      {0xe5032477ae8d46a5, 0x0000d6bf94d5e57a},
-      {0xc767074b22e90e21, 0x00002af31dc46118},
-      {0x8e47ce423a2e9c6d, 0x0000089705f4136b},
-      {0x4fa7f60d3ed61f49, 0x000001b7cdfd9d7b},
-      {0x0fee64690c913975, 0x00000057f5ff85e5},
-      {0x3662e0e1cf503eb1, 0x000000119799812d},
-      {0xa47a2cf9f6433fbd, 0x0000000384b84d09},
-      {0x54186f653140a659, 0x00000000b424dc35},
-      {0x7738164770402145, 0x0000000024075f3d},
-      {0xe4a4d1417cd9a041, 0x000000000734aca5},
-      {0xc75429d9e5c5200d, 0x000000000170ef54},
-      {0xc1773b91fac10669, 0x000000000049c977},
-      {0x26b172506559ce15, 0x00000000000ec1e4},
-      {0xd489e3a9addec2d1, 0x000000000002f394},
-      {0x90e860bb892c8d5d, 0x000000000000971d},
-      {0x502e79bf1b6f4f79, 0x0000000000001e39},
-      {0xdcd618596be30fe5, 0x000000000000060b}};
-  return x * divtest_table[exp].mod_inv <= divtest_table[exp].max_quotient;
-}
-
-// Replaces n by floor(n / pow(5, N)) returning true if and only if n is
-// divisible by pow(5, N).
-// Precondition: n <= 2 * pow(5, N + 1).
-template <int N>
-bool check_divisibility_and_divide_by_pow5(uint32_t& n) FMT_NOEXCEPT {
-  static constexpr struct {
-    uint32_t magic_number;
-    int bits_for_comparison;
-    uint32_t threshold;
-    int shift_amount;
-  } infos[] = {{0xcccd, 16, 0x3333, 18}, {0xa429, 8, 0x0a, 20}};
-  constexpr auto info = infos[N - 1];
-  n *= info.magic_number;
-  const uint32_t comparison_mask = (1u << info.bits_for_comparison) - 1;
-  bool result = (n & comparison_mask) <= info.threshold;
-  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> uint32_t small_division_by_pow10(uint32_t n) FMT_NOEXCEPT {
-  static constexpr struct {
-    uint32_t magic_number;
-    int shift_amount;
-    uint32_t divisor_times_10;
-  } infos[] = {{0xcccd, 19, 100}, {0xa3d8, 22, 1000}};
-  constexpr auto info = infos[N - 1];
-  FMT_ASSERT(n <= info.divisor_times_10, "n is too large");
-  return n * info.magic_number >> info.shift_amount;
-}
-
-// Computes floor(n / 10^(kappa + 1)) (float)
-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) FMT_NOEXCEPT {
-  return n / float_info<float>::big_divisor;
-}
-// Computes floor(n / 10^(kappa + 1)) (double)
-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) FMT_NOEXCEPT {
-  return umul128_upper64(n, 0x83126e978d4fdf3c) >> 9;
-}
-
-// Various subroutines using pow10 cache
-template <class T> struct cache_accessor;
-
-template <> struct cache_accessor<float> {
-  using carrier_uint = float_info<float>::carrier_uint;
-  using cache_entry_type = uint64_t;
-
-  static uint64_t get_cached_power(int k) FMT_NOEXCEPT {
-    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, 0x813f3978f8940984,
-        0xa18f07d736b90be5, 0xc9f2c9cd04674ede, 0xfc6f7c4045812296,
-        0x9dc5ada82b70b59d, 0xc5371912364ce305, 0xf684df56c3e01bc6,
-        0x9a130b963a6c115c, 0xc097ce7bc90715b3, 0xf0bdc21abb48db20,
-        0x96769950b50d88f4, 0xbc143fa4e250eb31, 0xeb194f8e1ae525fd,
-        0x92efd1b8d0cf37be, 0xb7abc627050305ad, 0xe596b7b0c643c719,
-        0x8f7e32ce7bea5c6f, 0xb35dbf821ae4f38b, 0xe0352f62a19e306e};
-    return pow10_significands[k - float_info<float>::min_k];
-  }
-
-  static carrier_uint compute_mul(carrier_uint u,
-                                  const cache_entry_type& cache) FMT_NOEXCEPT {
-    return umul96_upper32(u, cache);
-  }
-
-  static uint32_t compute_delta(const cache_entry_type& cache,
-                                int beta_minus_1) FMT_NOEXCEPT {
-    return static_cast<uint32_t>(cache >> (64 - 1 - beta_minus_1));
-  }
-
-  static bool compute_mul_parity(carrier_uint two_f,
-                                 const cache_entry_type& cache,
-                                 int beta_minus_1) FMT_NOEXCEPT {
-    FMT_ASSERT(beta_minus_1 >= 1, "");
-    FMT_ASSERT(beta_minus_1 < 64, "");
-
-    return ((umul96_lower64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
-  }
-
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return static_cast<carrier_uint>(
-        (cache - (cache >> (float_info<float>::significand_bits + 2))) >>
-        (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
-  }
-
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return static_cast<carrier_uint>(
-        (cache + (cache >> (float_info<float>::significand_bits + 1))) >>
-        (64 - float_info<float>::significand_bits - 1 - beta_minus_1));
-  }
-
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return (static_cast<carrier_uint>(
-                cache >>
-                (64 - float_info<float>::significand_bits - 2 - beta_minus_1)) +
-            1) /
-           2;
-  }
-};
-
-template <> struct cache_accessor<double> {
-  using carrier_uint = float_info<double>::carrier_uint;
-  using cache_entry_type = uint128_wrapper;
-
-  static uint128_wrapper get_cached_power(int k) FMT_NOEXCEPT {
-    FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
-               "k is out of range");
-
-    static constexpr const uint128_wrapper 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, 0xbff8f10e7a8921a4},
-      {0xa321f2d7226895c7, 0xaff72d52192b6a0d},
-      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764490},
-      {0xfee50b7025c36a08, 0x02f236d04753d5b4},
-      {0x9f4f2726179a2245, 0x01d762422c946590},
-      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef5},
-      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb2},
-      {0x9b934c3b330c8577, 0x63cc55f49f88eb2f},
-      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fb},
-      {0xf316271c7fc3908a, 0x8bef464e3945ef7a},
-      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ac},
-      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea317},
-      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bdd},
-      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6a},
-      {0xb975d6b6ee39e436, 0xb3e2fd538e122b44},
-      {0xe7d34c64a9c85d44, 0x60dbbca87196b616},
-      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31cd},
-      {0xb51d13aea4a488dd, 0x6babab6398bdbe41},
-      {0xe264589a4dcdab14, 0xc696963c7eed2dd1},
-      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca2},
-      {0xb0de65388cc8ada8, 0x3b25a55f43294bcb},
-      {0xdd15fe86affad912, 0x49ef0eb713f39ebe},
-      {0x8a2dbf142dfcc7ab, 0x6e3569326c784337},
-      {0xacb92ed9397bf996, 0x49c2c37f07965404},
-      {0xd7e77a8f87daf7fb, 0xdc33745ec97be906},
-      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a3},
-      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0c},
-      {0xd2d80db02aabd62b, 0xf50a3fa490c30190},
-      {0x83c7088e1aab65db, 0x792667c6da79e0fa},
-      {0xa4b8cab1a1563f52, 0x577001b891185938},
-      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
-      {0x80b05e5ac60b6178, 0x544f8158315b05b4},
-      {0xa0dc75f1778e39d6, 0x696361ae3db1c721},
-      {0xc913936dd571c84c, 0x03bc3a19cd1e38e9},
-      {0xfb5878494ace3a5f, 0x04ab48a04065c723},
-      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c76},
-      {0xc45d1df942711d9a, 0x3ba5d0bd324f8394},
-      {0xf5746577930d6500, 0xca8f44ec7ee36479},
-      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecb},
-      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67e},
-      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101e},
-      {0x95d04aee3b80ece5, 0xbba1f1d158724a12},
-      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc97},
-      {0xea1575143cf97226, 0xf52d09d71a3293bd},
-      {0x924d692ca61be758, 0x593c2626705f9c56},
-      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836c},
-      {0xe498f455c38b997a, 0x0b6dfb9c0f956447},
-      {0x8edf98b59a373fec, 0x4724bd4189bd5eac},
-      {0xb2977ee300c50fe7, 0x58edec91ec2cb657},
-      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ed},
-      {0x8b865b215899f46c, 0xbd79e0d20082ee74},
-      {0xae67f1e9aec07187, 0xecd8590680a3aa11},
-      {0xda01ee641a708de9, 0xe80e6f4820cc9495},
-      {0x884134fe908658b2, 0x3109058d147fdcdd},
-      {0xaa51823e34a7eede, 0xbd4b46f0599fd415},
-      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91a},
-      {0x850fadc09923329e, 0x03e2cf6bc604ddb0},
-      {0xa6539930bf6bff45, 0x84db8346b786151c},
-      {0xcfe87f7cef46ff16, 0xe612641865679a63},
-      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07e},
-      {0xa26da3999aef7749, 0xe3be5e330f38f09d},
-      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc5},
-      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f6},
-      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afa},
-      {0xc646d63501a1511d, 0xb281e1fd541501b8},
-      {0xf7d88bc24209a565, 0x1f225a7ca91a4226},
-      {0x9ae757596946075f, 0x3375788de9b06958},
-      {0xc1a12d2fc3978937, 0x0052d6b1641c83ae},
-      {0xf209787bb47d6b84, 0xc0678c5dbd23a49a},
-      {0x9745eb4d50ce6332, 0xf840b7ba963646e0},
-      {0xbd176620a501fbff, 0xb650e5a93bc3d898},
-      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebe},
-      {0x93ba47c980e98cdf, 0xc66f336c36b10137},
-      {0xb8a8d9bbe123f017, 0xb80b0047445d4184},
-      {0xe6d3102ad96cec1d, 0xa60dc059157491e5},
-      {0x9043ea1ac7e41392, 0x87c89837ad68db2f},
-      {0xb454e4a179dd1877, 0x29babe4598c311fb},
-      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67a},
-      {0x8ce2529e2734bb1d, 0x1899e4a65f58660c},
-      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f8f},
-      {0xdc21a1171d42645d, 0x76707543f4fa1f73},
-      {0x899504ae72497eba, 0x6a06494a791c53a8},
-      {0xabfa45da0edbde69, 0x0487db9d17636892},
-      {0xd6f8d7509292d603, 0x45a9d2845d3c42b6},
-      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
-      {0xa7f26836f282b732, 0x8e6cac7768d7141e},
-      {0xd1ef0244af2364ff, 0x3207d795430cd926},
-      {0x8335616aed761f1f, 0x7f44e6bd49e807b8},
-      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a6},
-      {0xcd036837130890a1, 0x36dba887c37a8c0f},
-      {0x802221226be55a64, 0xc2494954da2c9789},
-      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6c},
-      {0xc83553c5c8965d3d, 0x6f92829494e5acc7},
-      {0xfa42a8b73abbf48c, 0xcb772339ba1f17f9},
-      {0x9c69a97284b578d7, 0xff2a760414536efb},
-      {0xc38413cf25e2d70d, 0xfef5138519684aba},
-      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d69},
-      {0x98bf2f79d5993802, 0xef2f773ffbd97a61},
-      {0xbeeefb584aff8603, 0xaafb550ffacfd8fa},
-      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf38},
-      {0x952ab45cfa97a0b2, 0xdd945a747bf26183},
-      {0xba756174393d88df, 0x94f971119aeef9e4},
-      {0xe912b9d1478ceb17, 0x7a37cd5601aab85d},
-      {0x91abb422ccb812ee, 0xac62e055c10ab33a},
-      {0xb616a12b7fe617aa, 0x577b986b314d6009},
-      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80b},
-      {0x8e41ade9fbebc27d, 0x14588f13be847307},
-      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc8},
-      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bb},
-      {0x8aec23d680043bee, 0x25de7bb9480d5854},
-      {0xada72ccc20054ae9, 0xaf561aa79a10ae6a},
-      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
-      {0x87aa9aff79042286, 0x90fb44d2f05d0842},
-      {0xa99541bf57452b28, 0x353a1607ac744a53},
-      {0xd3fa922f2d1675f2, 0x42889b8997915ce8},
-      {0x847c9b5d7c2e09b7, 0x69956135febada11},
-      {0xa59bc234db398c25, 0x43fab9837e699095},
-      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bb},
-      {0x8161afb94b44f57d, 0x1d1be0eebac278f5},
-      {0xa1ba1ba79e1632dc, 0x6462d92a69731732},
-      {0xca28a291859bbf93, 0x7d7b8f7503cfdcfe},
-      {0xfcb2cb35e702af78, 0x5cda735244c3d43e},
-      {0x9defbf01b061adab, 0x3a0888136afa64a7},
-      {0xc56baec21c7a1916, 0x088aaa1845b8fdd0},
-      {0xf6c69a72a3989f5b, 0x8aad549e57273d45},
-      {0x9a3c2087a63f6399, 0x36ac54e2f678864b},
-      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7dd},
-      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d5},
-      {0x969eb7c47859e743, 0x9f644ae5a4b1b325},
-      {0xbc4665b596706114, 0x873d5d9f0dde1fee},
-      {0xeb57ff22fc0c7959, 0xa90cb506d155a7ea},
-      {0x9316ff75dd87cbd8, 0x09a7f12442d588f2},
-      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb2f},
-      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fa},
-      {0x8fa475791a569d10, 0xf96e017d694487bc},
-      {0xb38d92d760ec4455, 0x37c981dcc395a9ac},
-      {0xe070f78d3927556a, 0x85bbe253f47b1417},
-      {0x8c469ab843b89562, 0x93956d7478ccec8e},
-      {0xaf58416654a6babb, 0x387ac8d1970027b2},
-      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319e},
-      {0x88fcf317f22241e2, 0x441fece3bdf81f03},
-      {0xab3c2fddeeaad25a, 0xd527e81cad7626c3},
-      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b074},
-      {0x85c7056562757456, 0xf6872d5667844e49},
-      {0xa738c6bebb12d16c, 0xb428f8ac016561db},
-      {0xd106f86e69d785c7, 0xe13336d701beba52},
-      {0x82a45b450226b39c, 0xecc0024661173473},
-      {0xa34d721642b06084, 0x27f002d7f95d0190},
-      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f4},
-      {0xff290242c83396ce, 0x7e67047175a15271},
-      {0x9f79a169bd203e41, 0x0f0062c6e984d386},
-      {0xc75809c42c684dd1, 0x52c07b78a3e60868},
-      {0xf92e0c3537826145, 0xa7709a56ccdf8a82},
-      {0x9bbcc7a142b17ccb, 0x88a66076400bb691},
-      {0xc2abf989935ddbfe, 0x6acff893d00ea435},
-      {0xf356f7ebf83552fe, 0x0583f6b8c4124d43},
-      {0x98165af37b2153de, 0xc3727a337a8b704a},
-      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5c},
-      {0xeda2ee1c7064130c, 0x1162def06f79df73},
-      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba8},
-      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173692},
-      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0437},
-      {0x910ab1d4db9914a0, 0x1d9c9892400a22a2},
-      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4b},
-      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61d},
-      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
-      {0xb10d8e1456105dad, 0x7425a83e872c5f47},
-      {0xdd50f1996b947518, 0xd12f124e28f77719},
-      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa6f},
-      {0xace73cbfdc0bfb7b, 0x636cc64d1001550b},
-      {0xd8210befd30efa5a, 0x3c47f7e05401aa4e},
-      {0x8714a775e3e95c78, 0x65acfaec34810a71},
-      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0d},
-      {0xd31045a8341ca07c, 0x1ede48111209a050},
-      {0x83ea2b892091e44d, 0x934aed0aab460432},
-      {0xa4e4b66b68b65d60, 0xf81da84d5617853f},
-      {0xce1de40642e3f4b9, 0x36251260ab9d668e},
-      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b426019},
-      {0xa1075a24e4421730, 0xb24cf65b8612f81f},
-      {0xc94930ae1d529cfc, 0xdee033f26797b627},
-      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b1},
-      {0x9d412e0806e88aa5, 0x8e1f289560ee864e},
-      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e2},
-      {0xf5b5d7ec8acb58a2, 0xae10af696774b1db},
-      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef29},
-      {0xbff610b0cc6edd3f, 0x17fd090a58d32af3},
-      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b0},
-      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98e},
-      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f1},
-      {0xea53df5fd18d5513, 0x84c86189216dc5ed},
-      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb4},
-      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a1},
-      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
-      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400e},
-      {0xb2c71d5bca9023f8, 0x743e20e9ef511012},
-      {0xdf78e4b2bd342cf6, 0x914da9246b255416},
-      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548e},
-      {0xae9672aba3d0c320, 0xa184ac2473b529b1},
-      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741e},
-      {0x8865899617fb1871, 0x7e2fa67c7a658892},
-      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab7},
-      {0xd51ea6fa85785631, 0x552a74227f3ea565},
-      {0x8533285c936b35de, 0xd53a88958f87275f},
-      {0xa67ff273b8460356, 0x8a892abaf368f137},
-      {0xd01fef10a657842c, 0x2d2b7569b0432d85},
-      {0x8213f56a67f6b29b, 0x9c3b29620e29fc73},
-      {0xa298f2c501f45f42, 0x8349f3ba91b47b8f},
-      {0xcb3f2f7642717713, 0x241c70a936219a73},
-      {0xfe0efb53d30dd4d7, 0xed238cd383aa0110},
-      {0x9ec95d1463e8a506, 0xf4363804324a40aa},
-      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d5},
-      {0xf81aa16fdc1b81da, 0xdd94b7868e94050a},
-      {0x9b10a4e5e9913128, 0xca7cf2b4191c8326},
-      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f0},
-      {0xf24a01a73cf2dccf, 0xbc633b39673c8cec},
-      {0x976e41088617ca01, 0xd5be0503e085d813},
-      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e18},
-      {0xec9c459d51852ba2, 0xddf8e7d60ed1219e},
-      {0x93e1ab8252f33b45, 0xcabb90e5c942b503},
-      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
-      {0xe7109bfba19c0c9d, 0x0cc512670a783ad4},
-      {0x906a617d450187e2, 0x27fb2b80668b24c5},
-      {0xb484f9dc9641e9da, 0xb1f9f660802dedf6},
-      {0xe1a63853bbd26451, 0x5e7873f8a0396973},
-      {0x8d07e33455637eb2, 0xdb0b487b6423e1e8},
-      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda62},
-      {0xdc5c5301c56b75f7, 0x7641a140cc7810fb},
-      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9d},
-      {0xac2820d9623bf429, 0x546345fa9fbdcd44},
-      {0xd732290fbacaf133, 0xa97c177947ad4095},
-      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485d},
-      {0xa81f301449ee8c70, 0x5c68f256bfff5a74},
-      {0xd226fc195c6a2f8c, 0x73832eec6fff3111},
-      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eab},
-      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e55},
-      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35eb},
-      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b3},
-      {0xa0555e361951c366, 0xd7e105bcc332621f},
-      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa7},
-      {0xfa856334878fc150, 0xb14f98f6f0feb951},
-      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d3},
-      {0xc3b8358109e84f07, 0x0a862f80ec4700c8},
-      {0xf4a642e14c6262c8, 0xcd27bb612758c0fa},
-      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789c},
-      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c3},
-      {0xeeea5d5004981478, 0x1858ccfce06cac74},
-      {0x95527a5202df0ccb, 0x0f37801e0c43ebc8},
-      {0xbaa718e68396cffd, 0xd30560258f54e6ba},
-      {0xe950df20247c83fd, 0x47c6b82ef32a2069},
-      {0x91d28b7416cdd27e, 0x4cdc331d57fa5441},
-      {0xb6472e511c81471d, 0xe0133fe4adf8e952},
-      {0xe3d8f9e563a198e5, 0x58180fddd97723a6},
-      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7648},
-      {0xb201833b35d63f73, 0x2cd2cc6551e513da},
-      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d1},
-      {0x8b112e86420f6191, 0xfb04afaf27faf782},
-      {0xadd57a27d29339f6, 0x79c5db9af1f9b563},
-      {0xd94ad8b1c7380874, 0x18375281ae7822bc},
-      {0x87cec76f1c830548, 0x8f2293910d0b15b5},
-      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb22},
-      {0xd433179d9c8cb841, 0x5fa60692a46151eb},
-      {0x849feec281d7f328, 0xdbc7c41ba6bcd333},
-      {0xa5c7ea73224deff3, 0x12b9b522906c0800},
-      {0xcf39e50feae16bef, 0xd768226b34870a00},
-      {0x81842f29f2cce375, 0xe6a1158300d46640},
-      {0xa1e53af46f801c53, 0x60495ae3c1097fd0},
-      {0xca5e89b18b602368, 0x385bb19cb14bdfc4},
-      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b5},
-      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d1},
-      {0xc5a05277621be293, 0xc7098b7305241885},
-      { 0xf70867153aa2db38,
-        0xb8cbee4fc66d1ea7 }
-#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, 0x02f236d04753d5b4},
-      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f86},
-      {0xa6539930bf6bff45, 0x84db8346b786151c},
-      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b2},
-      {0xd910f7ff28069da4, 0x1b2ba1518094da04},
-      {0xaf58416654a6babb, 0x387ac8d1970027b2},
-      {0x8da471a9de737e24, 0x5ceaecfed289e5d2},
-      {0xe4d5e82392a40515, 0x0fabaf3feaa5334a},
-      {0xb8da1662e7b00a17, 0x3d6a751f3b936243},
-      { 0x95527a5202df0ccb,
-        0x0f37801e0c43ebc8 }
-#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 constexpr const uint32_t pow10_recovery_errors[] = {
-        0x50001400, 0x54044100, 0x54014555, 0x55954415, 0x54115555, 0x00000001,
-        0x50000000, 0x00104000, 0x54010004, 0x05004001, 0x55555544, 0x41545555,
-        0x54040551, 0x15445545, 0x51555514, 0x10000015, 0x00101100, 0x01100015,
-        0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04450514, 0x45414110,
-        0x55555145, 0x50544050, 0x15040155, 0x11054140, 0x50111514, 0x11451454,
-        0x00400541, 0x00000000, 0x55555450, 0x10056551, 0x10054011, 0x55551014,
-        0x69514555, 0x05151109, 0x00155555};
-
-    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_wrapper 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_wrapper recovered_cache = umul128(base_cache.high(), pow5);
-    uint128_wrapper middle_low =
-        umul128(base_cache.low() - (kb < 0 ? 1u : 0u), 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_wrapper{(recovered_cache.low() >> alpha) | high_to_middle,
-                        ((middle_low.low() >> alpha) | middle_to_low)};
-
-    if (kb < 0) recovered_cache += 1;
-
-    // Get error.
-    int error_idx = (k - float_info<double>::min_k) / 16;
-    uint32_t error = (pow10_recovery_errors[error_idx] >>
-                      ((k - float_info<double>::min_k) % 16) * 2) &
-                     0x3;
-
-    // Add the error back.
-    FMT_ASSERT(recovered_cache.low() + error >= recovered_cache.low(), "");
-    return {recovered_cache.high(), recovered_cache.low() + error};
-#endif
-  }
-
-  static carrier_uint compute_mul(carrier_uint u,
-                                  const cache_entry_type& cache) FMT_NOEXCEPT {
-    return umul192_upper64(u, cache);
-  }
-
-  static uint32_t compute_delta(cache_entry_type const& cache,
-                                int beta_minus_1) FMT_NOEXCEPT {
-    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta_minus_1));
-  }
-
-  static bool compute_mul_parity(carrier_uint two_f,
-                                 const cache_entry_type& cache,
-                                 int beta_minus_1) FMT_NOEXCEPT {
-    FMT_ASSERT(beta_minus_1 >= 1, "");
-    FMT_ASSERT(beta_minus_1 < 64, "");
-
-    return ((umul192_middle64(two_f, cache) >> (64 - beta_minus_1)) & 1) != 0;
-  }
-
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return (cache.high() -
-            (cache.high() >> (float_info<double>::significand_bits + 2))) >>
-           (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
-  }
-
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return (cache.high() +
-            (cache.high() >> (float_info<double>::significand_bits + 1))) >>
-           (64 - float_info<double>::significand_bits - 1 - beta_minus_1);
-  }
-
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta_minus_1) FMT_NOEXCEPT {
-    return ((cache.high() >>
-             (64 - float_info<double>::significand_bits - 2 - beta_minus_1)) +
-            1) /
-           2;
-  }
-};
-
-// Various integer checks
-template <class T>
-bool is_left_endpoint_integer_shorter_interval(int exponent) FMT_NOEXCEPT {
-  return exponent >=
-             float_info<
-                 T>::case_shorter_interval_left_endpoint_lower_threshold &&
-         exponent <=
-             float_info<T>::case_shorter_interval_left_endpoint_upper_threshold;
-}
-template <class T>
-bool is_endpoint_integer(typename float_info<T>::carrier_uint two_f,
-                         int exponent, int minus_k) FMT_NOEXCEPT {
-  if (exponent < float_info<T>::case_fc_pm_half_lower_threshold) return false;
-  // For k >= 0.
-  if (exponent <= float_info<T>::case_fc_pm_half_upper_threshold) return true;
-  // For k < 0.
-  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
-  return divisible_by_power_of_5(two_f, minus_k);
-}
-
-template <class T>
-bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
-                       int minus_k) FMT_NOEXCEPT {
-  // Exponent for 5 is negative.
-  if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
-  if (exponent > float_info<T>::case_fc_upper_threshold)
-    return divisible_by_power_of_5(two_f, minus_k);
-  // Both exponents are nonnegative.
-  if (exponent >= float_info<T>::case_fc_lower_threshold) return true;
-  // Exponent for 2 is negative.
-  return divisible_by_power_of_2(two_f, minus_k - exponent + 1);
-}
-
-// Remove trailing zeros from n and return the number of zeros removed (float)
-FMT_INLINE int remove_trailing_zeros(uint32_t& n) FMT_NOEXCEPT {
-#ifdef FMT_BUILTIN_CTZ
-  int t = FMT_BUILTIN_CTZ(n);
-#else
-  int t = ctz(n);
-#endif
-  if (t > float_info<float>::max_trailing_zeros)
-    t = float_info<float>::max_trailing_zeros;
-
-  const uint32_t mod_inv1 = 0xcccccccd;
-  const uint32_t max_quotient1 = 0x33333333;
-  const uint32_t mod_inv2 = 0xc28f5c29;
-  const uint32_t max_quotient2 = 0x0a3d70a3;
-
-  int s = 0;
-  for (; s < t - 1; s += 2) {
-    if (n * mod_inv2 > max_quotient2) break;
-    n *= mod_inv2;
-  }
-  if (s < t && n * mod_inv1 <= max_quotient1) {
-    n *= mod_inv1;
-    ++s;
-  }
-  n >>= s;
-  return s;
-}
-
-// Removes trailing zeros and returns the number of zeros removed (double)
-FMT_INLINE int remove_trailing_zeros(uint64_t& n) FMT_NOEXCEPT {
-#ifdef FMT_BUILTIN_CTZLL
-  int t = FMT_BUILTIN_CTZLL(n);
-#else
-  int t = ctzll(n);
-#endif
-  if (t > float_info<double>::max_trailing_zeros)
-    t = float_info<double>::max_trailing_zeros;
-  // Divide by 10^8 and reduce to 32-bits
-  // Since ret_value.significand <= (2^64 - 1) / 1000 < 10^17,
-  // both of the quotient and the r should fit in 32-bits
-
-  const uint32_t mod_inv1 = 0xcccccccd;
-  const uint32_t max_quotient1 = 0x33333333;
-  const uint64_t mod_inv8 = 0xc767074b22e90e21;
-  const uint64_t max_quotient8 = 0x00002af31dc46118;
-
-  // If the number is divisible by 1'0000'0000, work with the quotient
-  if (t >= 8) {
-    auto quotient_candidate = n * mod_inv8;
-
-    if (quotient_candidate <= max_quotient8) {
-      auto quotient = static_cast<uint32_t>(quotient_candidate >> 8);
-
-      int s = 8;
-      for (; s < t; ++s) {
-        if (quotient * mod_inv1 > max_quotient1) break;
-        quotient *= mod_inv1;
-      }
-      quotient >>= (s - 8);
-      n = quotient;
-      return s;
-    }
-  }
-
-  // Otherwise, work with the remainder
-  auto quotient = static_cast<uint32_t>(n / 100000000);
-  auto remainder = static_cast<uint32_t>(n - 100000000 * quotient);
-
-  if (t == 0 || remainder * mod_inv1 > max_quotient1) {
-    return 0;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 1 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 1) + quotient * 10000000ull;
-    return 1;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 2 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 2) + quotient * 1000000ull;
-    return 2;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 3 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 3) + quotient * 100000ull;
-    return 3;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 4 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 4) + quotient * 10000ull;
-    return 4;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 5 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 5) + quotient * 1000ull;
-    return 5;
-  }
-  remainder *= mod_inv1;
-
-  if (t == 6 || remainder * mod_inv1 > max_quotient1) {
-    n = (remainder >> 6) + quotient * 100ull;
-    return 6;
-  }
-  remainder *= mod_inv1;
-
-  n = (remainder >> 7) + quotient * 10ull;
-  return 7;
-}
-
-// The main algorithm for shorter interval case
-template <class T>
-FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) FMT_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_minus_1 = 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_minus_1);
-  auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
-      cache, beta_minus_1);
-
-  // 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_minus_1);
-  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> decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
-  // 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) << float_info<T>::significand_bits) - 1;
-  carrier_uint significand = (br & significand_mask);
-  int exponent = static_cast<int>((br & exponent_mask<T>()) >>
-                                  float_info<T>::significand_bits);
-
-  if (exponent != 0) {  // Check if normal.
-    exponent += float_info<T>::exponent_bias - float_info<T>::significand_bits;
-
-    // Shorter interval case; proceed like Schubfach.
-    if (significand == 0) return shorter_interval_case<T>(exponent);
-
-    significand |=
-        (static_cast<carrier_uint>(1) << float_info<T>::significand_bits);
-  } else {
-    // Subnormal case; the interval is always regular.
-    if (significand == 0) return {0, 0};
-    exponent = float_info<T>::min_exponent - float_info<T>::significand_bits;
-  }
-
-  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_minus_1 = 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_minus_1);
-  const carrier_uint two_fc = significand << 1;
-  const carrier_uint two_fr = two_fc | 1;
-  const carrier_uint zi =
-      cache_accessor<T>::compute_mul(two_fr << beta_minus_1, 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(zi);
-  uint32_t r = static_cast<uint32_t>(zi - float_info<T>::big_divisor *
-                                              ret_value.significand);
-
-  if (r > deltai) {
-    goto small_divisor_case_label;
-  } else if (r < deltai) {
-    // Exclude the right endpoint if necessary
-    if (r == 0 && !include_right_endpoint &&
-        is_endpoint_integer<T>(two_fr, exponent, minus_k)) {
-      --ret_value.significand;
-      r = float_info<T>::big_divisor;
-      goto small_divisor_case_label;
-    }
-  } else {
-    // r == deltai; compare fractional parts
-    // Check conditions in the order different from the paper
-    // to take advantage of short-circuiting
-    const carrier_uint two_fl = two_fc - 1;
-    if ((!include_left_endpoint ||
-         !is_endpoint_integer<T>(two_fl, exponent, minus_k)) &&
-        !cache_accessor<T>::compute_mul_parity(two_fl, cache, beta_minus_1)) {
-      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;
-
-  const uint32_t mask = (1u << float_info<T>::kappa) - 1;
-  auto dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
-
-  // Is dist divisible by 2^kappa?
-  if ((dist & mask) == 0) {
-    const bool approx_y_parity =
-        ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
-    dist >>= float_info<T>::kappa;
-
-    // Is dist divisible by 5^kappa?
-    if (check_divisibility_and_divide_by_pow5<float_info<T>::kappa>(dist)) {
-      ret_value.significand += dist;
-
-      // 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
-      if (cache_accessor<T>::compute_mul_parity(two_fc, cache, beta_minus_1) !=
-          approx_y_parity) {
-        --ret_value.significand;
-      } else {
-        // If z^(f) >= epsilon^(f), we might have a tie
-        // when z^(f) == epsilon^(f), or equivalently, when y is an integer
-        if (is_center_integer<T>(two_fc, exponent, minus_k)) {
-          ret_value.significand = ret_value.significand % 2 == 0
-                                      ? ret_value.significand
-                                      : ret_value.significand - 1;
-        }
-      }
-    }
-    // Is dist not divisible by 5^kappa?
-    else {
-      ret_value.significand += dist;
-    }
-  }
-  // Is dist not divisible by 2^kappa?
-  else {
-    // Since we know dist is small, we might be able to optimize the division
-    // better than the compiler; we are computing dist / small_divisor here
-    ret_value.significand +=
-        small_division_by_pow10<float_info<T>::kappa>(dist);
-  }
-  return ret_value;
-}
-}  // namespace dragonbox
-
-// 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(fp value, bool is_predecessor_closer,
-                                          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.
-  int shift = is_predecessor_closer ? 2 : 1;
-  uint64_t significand = value.f << shift;
-  if (value.e >= 0) {
-    numerator.assign(significand);
-    numerator <<= value.e;
-    lower.assign(1);
-    lower <<= value.e;
-    if (shift != 1) {
-      upper_store.assign(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 (shift != 1) {
-      upper_store.assign(numerator);
-      upper_store <<= 1;
-      upper = &upper_store;
-    }
-    numerator *= significand;
-    denominator.assign(1);
-    denominator <<= shift - value.e;
-  } else {
-    numerator.assign(significand);
-    denominator.assign_pow10(exp10);
-    denominator <<= shift - value.e;
-    lower.assign(1);
-    if (shift != 1) {
-      upper_store.assign(1ULL << 1);
-      upper = &upper_store;
-    }
-  }
-  // Invariant: value == (numerator / denominator) * pow(10, exp10).
-  if (num_digits < 0) {
-    // Generate the shortest representation.
-    if (!upper) upper = &lower;
-    bool even = (value.f & 1) == 0;
-    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';
-        ++exp10;
-      }
-      return;
-    }
-    ++digit;
-  }
-  buf[num_digits - 1] = static_cast<char>('0' + digit);
-}
-
-template <typename Float>
-FMT_HEADER_ONLY_CONSTEXPR20 int format_float(Float value, int precision,
-                                             float_specs specs,
-                                             buffer<char>& buf) {
-  // 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");
-
-  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;
-  }
-
-  if (specs.fallback) return snprintf_float(value, precision, specs, buf);
-
-  if (!is_constant_evaluated() && 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;
-  }
-
-  int exp = 0;
-  bool use_dragon = true;
-  if (is_fast_float<Float>()) {
-    // Use Grisu + Dragon4 for the given precision:
-    // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
-    const int min_exp = -60;  // alpha in Grisu.
-    int cached_exp10 = 0;     // K in Grisu.
-    fp normalized = normalize(fp(value));
-    const auto cached_pow = get_cached_power(
-        min_exp - (normalized.e + fp::num_significand_bits), cached_exp10);
-    normalized = normalized * cached_pow;
-    gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
-    if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error &&
-        !is_constant_evaluated()) {
-      exp += handler.exp10;
-      buf.try_resize(to_unsigned(handler.size));
-      use_dragon = false;
-    } else {
-      exp += handler.size - cached_exp10 - 1;
-      precision = handler.precision;
-    }
-  }
-  if (use_dragon) {
-    auto f = fp();
-    bool is_predecessor_closer =
-        specs.binary32 ? f.assign(static_cast<float>(value)) : f.assign(value);
-    // 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, is_predecessor_closer, 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 T>
-int snprintf_float(T value, int precision, float_specs specs,
-                   buffer<char>& buf) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
-  static_assert(!std::is_same<T, float>::value, "");
-
-  // Subtract 1 to account for the difference in precision since we use %e for
-  // both general and exponent format.
-  if (specs.format == float_format::general ||
-      specs.format == float_format::exp)
-    precision = (precision >= 0 ? precision : 6) - 1;
-
-  // Build the format string.
-  enum { max_format_size = 7 };  // The longest format is "%#.*Le".
-  char format[max_format_size];
-  char* format_ptr = format;
-  *format_ptr++ = '%';
-  if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
-  if (precision >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
-  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
-  *format_ptr++ = specs.format != float_format::hex
-                      ? (specs.format == float_format::fixed ? 'f' : 'e')
-                      : (specs.upper ? 'A' : 'a');
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  auto offset = buf.size();
-  for (;;) {
-    auto begin = buf.data() + offset;
-    auto capacity = buf.capacity() - offset;
-#ifdef FMT_FUZZ
-    if (precision > 100000)
-      throw std::runtime_error(
-          "fuzz mode - avoid large allocation inside snprintf");
-#endif
-    // Suppress the warning about a nonliteral format string.
-    // Cannot use auto because of a bug in MinGW (#1532).
-    int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
-    int result = precision >= 0
-                     ? snprintf_ptr(begin, capacity, format, precision, value)
-                     : snprintf_ptr(begin, capacity, format, value);
-    if (result < 0) {
-      // The buffer will grow exponentially.
-      buf.try_reserve(buf.capacity() + 1);
-      continue;
-    }
-    auto size = to_unsigned(result);
-    // Size equal to capacity means that the last character was truncated.
-    if (size >= capacity) {
-      buf.try_reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
-      continue;
-    }
-    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
-    if (specs.format == float_format::fixed) {
-      if (precision == 0) {
-        buf.try_resize(size);
-        return 0;
-      }
-      // Find and remove the decimal point.
-      auto end = begin + size, p = end;
-      do {
-        --p;
-      } while (is_digit(*p));
-      int fraction_size = static_cast<int>(end - p - 1);
-      std::memmove(p, p + 1, to_unsigned(fraction_size));
-      buf.try_resize(size - 1);
-      return -fraction_size;
-    }
-    if (specs.format == float_format::hex) {
-      buf.try_resize(size + offset);
-      return 0;
-    }
-    // Find and parse the exponent.
-    auto end = begin + size, exp_pos = end;
-    do {
-      --exp_pos;
-    } while (*exp_pos != 'e');
-    char sign = exp_pos[1];
-    FMT_ASSERT(sign == '+' || sign == '-', "");
-    int exp = 0;
-    auto p = exp_pos + 2;  // Skip 'e' and sign.
-    do {
-      FMT_ASSERT(is_digit(*p), "");
-      exp = exp * 10 + (*p++ - '0');
-    } while (p != end);
-    if (sign == '-') exp = -exp;
-    int fraction_size = 0;
-    if (exp_pos != begin + 1) {
-      // Remove trailing zeros.
-      auto fraction_end = exp_pos - 1;
-      while (*fraction_end == '0') --fraction_end;
-      // Move the fractional part left to get rid of the decimal point.
-      fraction_size = static_cast<int>(fraction_end - begin - 1);
-      std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
-    }
-    buf.try_resize(to_unsigned(fraction_size) + offset + 1);
-    return exp - fraction_size;
-  }
-}
-}  // namespace detail
-
-template <> struct formatter<detail::bigint> {
-  FMT_CONSTEXPR format_parse_context::iterator parse(
-      format_parse_context& ctx) {
-    return ctx.begin();
-  }
-
-  format_context::iterator format(const detail::bigint& n,
-                                  format_context& ctx) {
-    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 = format_to(out, FMT_STRING("{:x}"), value);
-        first = false;
-        continue;
-      }
-      out = format_to(out, FMT_STRING("{:08x}"), value);
-    }
-    if (n.exp_ > 0)
-      out = 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) FMT_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) FMT_NOEXCEPT {
-  report_error(format_system_error, error_code, message);
-}
-
-// DEPRECATED!
-// This function is defined here and not inline for ABI compatiblity.
-FMT_FUNC void detail::error_handler::on_error(const char* message) {
-  throw_format_error(message);
-}
-
-FMT_FUNC std::string vformat(string_view fmt, format_args args) {
-  // 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);
-}
-
-#ifdef _WIN32
-namespace detail {
-using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
-extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
-    void*, const void*, dword, dword*, void*);
-}  // namespace detail
-#endif
-
-namespace detail {
-FMT_FUNC void print(std::FILE* f, string_view text) {
-#ifdef _WIN32
-  auto fd = _fileno(f);
-  if (_isatty(fd)) {
-    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
-    auto written = detail::dword();
-    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
-                              u16.c_str(), static_cast<uint32_t>(u16.size()),
-                              &written, nullptr)) {
-      return;
-    }
-    // Fallback to fwrite on failure. It can happen if the output has been
-    // redirected to NUL.
-  }
-#endif
-  detail::fwrite_fully(text.data(), 1, text.size(), f);
-}
-}  // namespace detail
-
-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str, args);
-  detail::print(f, {buffer.data(), buffer.size()});
-}
-
-#ifdef _WIN32
-// Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
-                                      format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str,
-                     basic_format_args<buffer_context<char>>(args));
-  fwrite_fully(buffer.data(), 1, buffer.size(), f);
-}
-#endif
-
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_FORMAT_INL_H_
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/locale.h b/wpiutil/src/main/native/fmtlib/include/fmt/locale.h
deleted file mode 100644
index 7571b52..0000000
--- a/wpiutil/src/main/native/fmtlib/include/fmt/locale.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "xchar.h"
-#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/ostream.h b/wpiutil/src/main/native/fmtlib/include/fmt/ostream.h
deleted file mode 100644
index 3d716ec..0000000
--- a/wpiutil/src/main/native/fmtlib/include/fmt/ostream.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#include <ostream>
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-template <typename OutputIt, typename Char> class basic_printf_context;
-
-namespace detail {
-
-// Checks if T has a user-defined operator<<.
-template <typename T, typename Char, typename Enable = void>
-class is_streamable {
- private:
-  template <typename U>
-  static auto test(int)
-      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
-                              << std::declval<U>()) != 0>;
-
-  template <typename> static auto test(...) -> std::false_type;
-
-  using result = decltype(test<T>(0));
-
- public:
-  is_streamable() = default;
-
-  static const bool value = result::value;
-};
-
-// Formatting of built-in types and arrays is intentionally disabled because
-// it's handled by standard (non-ostream) formatters.
-template <typename T, typename Char>
-struct is_streamable<
-    T, Char,
-    enable_if_t<
-        std::is_arithmetic<T>::value || std::is_array<T>::value ||
-        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
-        std::is_same<T, std::basic_string<Char>>::value ||
-        std::is_same<T, std_string_view<Char>>::value ||
-        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
-    : std::false_type {};
-
-// 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,
-                  locale_ref loc = locale_ref()) {
-  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
-  auto&& output = std::basic_ostream<Char>(&format_buf);
-#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
-  if (loc) output.imbue(loc.get<std::locale>());
-#endif
-  output << value;
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  buf.try_resize(buf.size());
-}
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
-    : private formatter<basic_string_view<Char>, Char> {
-  using formatter<basic_string_view<Char>, Char>::parse;
-
-  template <typename OutputIt>
-  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
-      -> OutputIt {
-    auto buffer = basic_memory_buffer<Char>();
-    format_value(buffer, value, ctx.locale());
-    return formatter<basic_string_view<Char>, Char>::format(
-        {buffer.data(), buffer.size()}, ctx);
-  }
-
-  // DEPRECATED!
-  template <typename OutputIt>
-  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
-      -> OutputIt {
-    auto buffer = basic_memory_buffer<Char>();
-    format_value(buffer, value, ctx.locale());
-    return std::copy(buffer.begin(), buffer.end(), ctx.out());
-  }
-};
-}  // namespace detail
-
-FMT_MODULE_EXPORT
-template <typename Char>
-void vprint(std::basic_ostream<Char>& os, basic_string_view<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);
-  detail::write_buffer(os, buffer);
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fmt::print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-FMT_MODULE_EXPORT
-template <typename S, typename... Args,
-          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
-void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
-  vprint(os, to_string_view(format_str),
-         fmt::make_args_checked<Args...>(format_str, args...));
-}
-FMT_END_NAMESPACE
-
-#endif  // FMT_OSTREAM_H_
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/ranges.h b/wpiutil/src/main/native/fmtlib/include/fmt/ranges.h
deleted file mode 100644
index eb9fb8a..0000000
--- a/wpiutil/src/main/native/fmtlib/include/fmt/ranges.h
+++ /dev/null
@@ -1,793 +0,0 @@
-// Formatting library for C++ - experimental range support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-//
-// Copyright (c) 2018 - present, Remotion (Igor Schulz)
-// All Rights Reserved
-// {fmt} support for ranges, containers and types tuple interface.
-
-#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 RangeT, typename OutputIterator>
-OutputIterator copy(const RangeT& range, OutputIterator out) {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
-  return out;
-}
-
-template <typename OutputIterator>
-OutputIterator copy(const char* str, OutputIterator out) {
-  while (*str) *out++ = *str++;
-  return out;
-}
-
-template <typename OutputIterator>
-OutputIterator copy(char ch, OutputIterator out) {
-  *out++ = ch;
-  return out;
-}
-
-template <typename OutputIterator>
-OutputIterator copy(wchar_t ch, OutputIterator out) {
-  *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 FMT_CONSTEXPR_DECL 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
-  static FMT_CONSTEXPR_DECL const bool value = false;
-#else
-  static FMT_CONSTEXPR_DECL 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
-  static FMT_CONSTEXPR_DECL const bool value = false;
-#else
-  static FMT_CONSTEXPR_DECL 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_VER || FMT_MSC_VER > 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>())),
-              enable_if_t<std::is_copy_constructible<T>::value>>>
-    : 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 FMT_CONSTEXPR_DECL const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-// Check for integer_sequence
-#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 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 size_t size() { 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 <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
-  using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
-}
-
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-    T const&) {
-  return {};
-}
-
-template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
-  const auto indexes = get_indexes(tup);
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
-}
-
-template <typename Range>
-using value_type =
-    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;
-
-template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
-  *out++ = ',';
-  *out++ = ' ';
-  return out;
-}
-
-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;
-}
-
-// Returns true iff the code point cp is printable.
-// This code is generated by support/printable.py.
-inline 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;
-}
-
-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>
-auto find_escape(const Char* begin, const Char* end)
-    -> find_escape_result<Char> {
-  for (; begin != end; ++begin) {
-    auto cp = static_cast<typename std::make_unsigned<Char>::type>(*begin);
-    if (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;
-}
-
-template <typename Char, typename OutputIt>
-auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
-  *out++ = '"';
-  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;
-    auto c = static_cast<Char>(escape.cp);
-    switch (escape.cp) {
-    case '\n':
-      *out++ = '\\';
-      c = 'n';
-      break;
-    case '\r':
-      *out++ = '\\';
-      c = 'r';
-      break;
-    case '\t':
-      *out++ = '\\';
-      c = 't';
-      break;
-    case '"':
-      FMT_FALLTHROUGH;
-    case '\\':
-      *out++ = '\\';
-      break;
-    default:
-      if (is_utf8()) {
-        if (escape.cp < 0x100) {
-          out = format_to(out, "\\x{:02x}", escape.cp);
-          continue;
-        }
-        if (escape.cp < 0x10000) {
-          out = format_to(out, "\\u{:04x}", escape.cp);
-          continue;
-        }
-        if (escape.cp < 0x110000) {
-          out = format_to(out, "\\U{:08x}", escape.cp);
-          continue;
-        }
-      }
-      for (Char escape_char : basic_string_view<Char>(
-               escape.begin, to_unsigned(escape.end - escape.begin))) {
-        out = format_to(
-            out, "\\x{:02x}",
-            static_cast<typename std::make_unsigned<Char>::type>(escape_char));
-      }
-      continue;
-    }
-    *out++ = c;
-  } while (begin != end);
-  *out++ = '"';
-  return out;
-}
-
-template <typename Char, typename OutputIt, typename T,
-          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
-inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
-  auto sv = std_string_view<Char>(str);
-  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
-}
-
-template <typename Char, typename OutputIt, typename Arg,
-          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
-OutputIt write_range_entry(OutputIt out, const Arg v) {
-  *out++ = '\'';
-  *out++ = v;
-  *out++ = '\'';
-  return out;
-}
-
-template <
-    typename Char, typename OutputIt, typename Arg,
-    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
-                  !std::is_same<Arg, Char>::value)>
-OutputIt write_range_entry(OutputIt out, const Arg& v) {
-  return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-template <typename T> struct is_tuple_like {
-  static FMT_CONSTEXPR_DECL const bool value =
-      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
-};
-
-template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
- private:
-  // C++11 generic lambda for format().
-  template <typename FormatContext> struct format_each {
-    template <typename T> void operator()(const T& v) {
-      if (i > 0) out = detail::write_delimiter(out);
-      out = detail::write_range_entry<Char>(out, v);
-      ++i;
-    }
-    int i;
-    typename FormatContext::iterator& out;
-  };
-
- public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext = format_context>
-  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    *out++ = '(';
-    detail::for_each(values, format_each<FormatContext>{0, out});
-    *out++ = ')';
-    return out;
-  }
-};
-
-template <typename T, typename Char> struct is_range {
-  static FMT_CONSTEXPR_DECL const bool value =
-      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
-      !detail::is_map<T>::value &&
-      !std::is_convertible<T, std::basic_string<Char>>::value &&
-      !std::is_constructible<detail::std_string_view<Char>, T>::value;
-};
-
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<
-        fmt::is_range<T, Char>::value
-// Workaround a bug in MSVC 2019 and earlier.
-#if !FMT_MSC_VER
-        && (is_formattable<detail::value_type<T>, Char>::value ||
-            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
-#endif
-        >> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <
-      typename FormatContext, typename U,
-      FMT_ENABLE_IF(
-          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
-                                        const T, T>>::value)>
-  auto format(U& range, FormatContext& ctx) -> decltype(ctx.out()) {
-#ifdef FMT_DEPRECATED_BRACED_RANGES
-    Char prefix = '{';
-    Char postfix = '}';
-#else
-    Char prefix = detail::is_set<T>::value ? '{' : '[';
-    Char postfix = detail::is_set<T>::value ? '}' : ']';
-#endif
-    auto out = ctx.out();
-    *out++ = prefix;
-    int i = 0;
-    auto it = std::begin(range);
-    auto end = std::end(range);
-    for (; it != end; ++it) {
-      if (i > 0) out = detail::write_delimiter(out);
-      out = detail::write_range_entry<Char>(out, *it);
-      ++i;
-    }
-    *out++ = postfix;
-    return out;
-  }
-};
-
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<
-        detail::is_map<T>::value
-// Workaround a bug in MSVC 2019 and earlier.
-#if !FMT_MSC_VER
-        && (is_formattable<detail::value_type<T>, Char>::value ||
-            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
-#endif
-        >> {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
-
-  template <
-      typename FormatContext, typename U,
-      FMT_ENABLE_IF(
-          std::is_same<U, conditional_t<detail::has_const_begin_end<T>::value,
-                                        const T, T>>::value)>
-  auto format(U& map, FormatContext& ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    *out++ = '{';
-    int i = 0;
-    for (const auto& item : map) {
-      if (i > 0) out = detail::write_delimiter(out);
-      out = detail::write_range_entry<Char>(out, item.first);
-      *out++ = ':';
-      *out++ = ' ';
-      out = detail::write_range_entry<Char>(out, item.second);
-      ++i;
-    }
-    *out++ = '}';
-    return out;
-  }
-};
-
-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} {}
-};
-
-template <typename Char, typename... T>
-using tuple_arg_join = tuple_join_view<Char, T...>;
-
-// 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;
-  }
-};
-
-FMT_MODULE_EXPORT_BEGIN
-
-/**
-  \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_MODULE_EXPORT_END
-FMT_END_NAMESPACE
-
-#endif  // FMT_RANGES_H_
diff --git a/wpiutil/src/main/native/fmtlib/src/format.cpp b/wpiutil/src/main/native/fmtlib/src/format.cpp
deleted file mode 100644
index ecb8cc7..0000000
--- a/wpiutil/src/main/native/fmtlib/src/format.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-// 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 {
-
-// DEPRECATED!
-template <typename T = void> struct basic_data {
-  FMT_API static constexpr const char digits[100][2] = {
-      {'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'}};
-  FMT_API static constexpr const char hex_digits[] = "0123456789abcdef";
-  FMT_API static constexpr const char signs[4] = {0, '-', '+', ' '};
-  FMT_API static constexpr const char left_padding_shifts[5] = {31, 31, 0, 1,
-                                                                0};
-  FMT_API static constexpr const char right_padding_shifts[5] = {0, 31, 0, 1,
-                                                                 0};
-  FMT_API static constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
-                                                         0x1000000u | ' '};
-};
-
-#ifdef FMT_SHARED
-// Required for -flto, -fivisibility=hidden and -shared to work
-extern template struct basic_data<void>;
-#endif
-
-#if __cplusplus < 201703L
-// DEPRECATED! These are here only for ABI compatiblity.
-template <typename T> constexpr const char basic_data<T>::digits[][2];
-template <typename T> constexpr const char basic_data<T>::hex_digits[];
-template <typename T> constexpr const char basic_data<T>::signs[];
-template <typename T> constexpr const char basic_data<T>::left_padding_shifts[];
-template <typename T>
-constexpr const char basic_data<T>::right_padding_shifts[];
-template <typename T> constexpr const unsigned basic_data<T>::prefixes[];
-#endif
-
-template <typename T>
-int format_float(char* buf, std::size_t size, const char* format, int precision,
-                 T value) {
-#ifdef FMT_FUZZ
-  if (precision > 100000)
-    throw std::runtime_error(
-        "fuzz mode - avoid large allocation inside snprintf");
-#endif
-  // Suppress the warning about nonliteral format string.
-  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
-  return precision < 0 ? snprintf_ptr(buf, size, format, value)
-                       : snprintf_ptr(buf, size, format, precision, value);
-}
-
-template FMT_API dragonbox::decimal_fp<float> dragonbox::to_decimal(float x)
-    FMT_NOEXCEPT;
-template FMT_API dragonbox::decimal_fp<double> dragonbox::to_decimal(double x)
-    FMT_NOEXCEPT;
-}  // namespace detail
-
-// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
-int (*instantiate_format_float)(double, int, detail::float_specs,
-                                detail::buffer<char>&) = detail::format_float;
-
-#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
-template FMT_API detail::locale_ref::locale_ref(const std::locale& loc);
-template FMT_API std::locale detail::locale_ref::get<std::locale>() const;
-#endif
-
-// Explicit instantiations for char.
-
-template FMT_API auto detail::thousands_sep_impl(locale_ref)
-    -> thousands_sep_result<char>;
-template FMT_API char detail::decimal_point_impl(locale_ref);
-
-template FMT_API void detail::buffer<char>::append(const char*, const char*);
-
-// DEPRECATED!
-// There is no correspondent extern template in format.h because of
-// incompatibility between clang and gcc (#2377).
-template FMT_API void detail::vformat_to(
-    detail::buffer<char>&, string_view,
-    basic_format_args<FMT_BUFFER_CONTEXT(char)>, detail::locale_ref);
-
-template FMT_API int detail::snprintf_float(double, int, detail::float_specs,
-                                            detail::buffer<char>&);
-template FMT_API int detail::snprintf_float(long double, int,
-                                            detail::float_specs,
-                                            detail::buffer<char>&);
-template FMT_API int detail::format_float(double, int, detail::float_specs,
-                                          detail::buffer<char>&);
-template FMT_API int detail::format_float(long double, int, detail::float_specs,
-                                          detail::buffer<char>&);
-
-// Explicit instantiations for wchar_t.
-
-template FMT_API auto detail::thousands_sep_impl(locale_ref)
-    -> thousands_sep_result<wchar_t>;
-template FMT_API wchar_t detail::decimal_point_impl(locale_ref);
-
-template FMT_API void detail::buffer<wchar_t>::append(const wchar_t*,
-                                                      const wchar_t*);
-
-template struct detail::basic_data<void>;
-
-FMT_END_NAMESPACE
diff --git a/wpiutil/src/main/native/include/wpi/Algorithm.h b/wpiutil/src/main/native/include/wpi/Algorithm.h
index d0744dc..1fd2502 100644
--- a/wpiutil/src/main/native/include/wpi/Algorithm.h
+++ b/wpiutil/src/main/native/include/wpi/Algorithm.h
@@ -9,7 +9,7 @@
 
 namespace wpi {
 
-// Binary insortion into vector; std::log(n) efficiency.
+// Binary insertion into vector; std::log(n) efficiency.
 template <typename T>
 typename std::vector<T>::iterator insert_sorted(std::vector<T>& vec,
                                                 T const& item) {
diff --git a/wpiutil/src/main/native/include/wpi/AlignOf.h b/wpiutil/src/main/native/include/wpi/AlignOf.h
deleted file mode 100644
index adddd13..0000000
--- a/wpiutil/src/main/native/include/wpi/AlignOf.h
+++ /dev/null
@@ -1,146 +0,0 @@
-//===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the AlignedCharArray and AlignedCharArrayUnion classes.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_ALIGNOF_H
-#define WPIUTIL_WPI_ALIGNOF_H
-
-#include "wpi/Compiler.h"
-#include <cstddef>
-
-namespace wpi {
-
-/// \struct AlignedCharArray
-/// Helper for building an aligned character array type.
-///
-/// This template is used to explicitly build up a collection of aligned
-/// character array types. We have to build these up using a macro and explicit
-/// specialization to cope with MSVC (at least till 2015) where only an
-/// integer literal can be used to specify an alignment constraint. Once built
-/// up here, we can then begin to indirect between these using normal C++
-/// template parameters.
-
-// MSVC requires special handling here.
-#ifndef _MSC_VER
-
-template<std::size_t Alignment, std::size_t Size>
-struct AlignedCharArray {
-  alignas(Alignment) char buffer[Size];
-};
-
-#else // _MSC_VER
-
-/// Create a type with an aligned char buffer.
-template<std::size_t Alignment, std::size_t Size>
-struct AlignedCharArray;
-
-// We provide special variations of this template for the most common
-// alignments because __declspec(align(...)) doesn't actually work when it is
-// a member of a by-value function argument in MSVC, even if the alignment
-// request is something reasonably like 8-byte or 16-byte. Note that we can't
-// even include the declspec with the union that forces the alignment because
-// MSVC warns on the existence of the declspec despite the union member forcing
-// proper alignment.
-
-template<std::size_t Size>
-struct AlignedCharArray<1, Size> {
-  union {
-    char aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<2, Size> {
-  union {
-    short aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<4, Size> {
-  union {
-    int aligned;
-    char buffer[Size];
-  };
-};
-
-template<std::size_t Size>
-struct AlignedCharArray<8, Size> {
-  union {
-    double aligned;
-    char buffer[Size];
-  };
-};
-
-
-// The rest of these are provided with a __declspec(align(...)) and we simply
-// can't pass them by-value as function arguments on MSVC.
-
-#define LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
-  template<std::size_t Size> \
-  struct AlignedCharArray<x, Size> { \
-    __declspec(align(x)) char buffer[Size]; \
-  };
-
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64)
-LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128)
-
-#undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
-
-#endif // _MSC_VER
-
-namespace detail {
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-class AlignerImpl {
-  T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; T10 t10;
-
-  AlignerImpl() = delete;
-};
-
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-union SizerImpl {
-  char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)],
-       arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)], arr8[sizeof(T8)],
-       arr9[sizeof(T9)], arr10[sizeof(T10)];
-};
-} // end namespace detail
-
-/// This union template exposes a suitably aligned and sized character
-/// array member which can hold elements of any of up to ten types.
-///
-/// These types may be arrays, structs, or any other types. The goal is to
-/// expose a char array buffer member which can be used as suitable storage for
-/// a placement new of any of these types. Support for more than ten types can
-/// be added at the cost of more boilerplate.
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-struct AlignedCharArrayUnion : wpi::AlignedCharArray<
-    alignof(wpi::detail::AlignerImpl<T1, T2, T3, T4, T5,
-                                      T6, T7, T8, T9, T10>),
-    sizeof(::wpi::detail::SizerImpl<T1, T2, T3, T4, T5,
-                                     T6, T7, T8, T9, T10>)> {
-};
-} // end namespace wpi
-
-#endif // LLVM_SUPPORT_ALIGNOF_H
diff --git a/wpiutil/src/main/native/include/wpi/Base64.h b/wpiutil/src/main/native/include/wpi/Base64.h
index 41b0062..c410bd0 100644
--- a/wpiutil/src/main/native/include/wpi/Base64.h
+++ b/wpiutil/src/main/native/include/wpi/Base64.h
@@ -6,12 +6,11 @@
 #define WPIUTIL_WPI_BASE64_H_
 
 #include <cstddef>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
 
-#include "wpi/span.h"
-
 namespace wpi {
 template <typename T>
 class SmallVectorImpl;
@@ -26,8 +25,8 @@
 
 size_t Base64Decode(std::string_view encoded, std::vector<uint8_t>* plain);
 
-span<uint8_t> Base64Decode(std::string_view encoded, size_t* num_read,
-                           SmallVectorImpl<uint8_t>& buf);
+std::span<uint8_t> Base64Decode(std::string_view encoded, size_t* num_read,
+                                SmallVectorImpl<uint8_t>& buf);
 
 void Base64Encode(raw_ostream& os, std::string_view plain);
 
@@ -36,11 +35,11 @@
 std::string_view Base64Encode(std::string_view plain,
                               SmallVectorImpl<char>& buf);
 
-void Base64Encode(raw_ostream& os, span<const uint8_t> plain);
+void Base64Encode(raw_ostream& os, std::span<const uint8_t> plain);
 
-void Base64Encode(span<const uint8_t> plain, std::string* encoded);
+void Base64Encode(std::span<const uint8_t> plain, std::string* encoded);
 
-std::string_view Base64Encode(span<const uint8_t> plain,
+std::string_view Base64Encode(std::span<const uint8_t> plain,
                               SmallVectorImpl<char>& buf);
 
 }  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/Compiler.h b/wpiutil/src/main/native/include/wpi/Compiler.h
deleted file mode 100644
index 5ceb605..0000000
--- a/wpiutil/src/main/native/include/wpi/Compiler.h
+++ /dev/null
@@ -1,516 +0,0 @@
-//===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines several macros, based on the current compiler.  This allows
-// use of compiler-specific features in a way that remains portable.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_COMPILER_H
-#define WPIUTIL_WPI_COMPILER_H
-
-#include <new>
-#include <stddef.h>
-
-#if defined(_MSC_VER)
-#include <sal.h>
-#endif
-
-#ifndef __has_feature
-# define __has_feature(x) 0
-#endif
-
-#ifndef __has_extension
-# define __has_extension(x) 0
-#endif
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0
-#endif
-
-#ifndef __has_cpp_attribute
-# define __has_cpp_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-# define __has_builtin(x) 0
-#endif
-
-/// \macro LLVM_GNUC_PREREQ
-/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#ifndef LLVM_GNUC_PREREQ
-# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
-     ((maj) << 20) + ((min) << 10) + (patch))
-# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-# else
-#  define LLVM_GNUC_PREREQ(maj, min, patch) 0
-# endif
-#endif
-
-/// \macro LLVM_MSC_PREREQ
-/// Is the compiler MSVC of at least the specified version?
-/// The common \param version values to check for are:
-///  * 1900: Microsoft Visual Studio 2015 / 14.0
-#ifndef LLVM_MSC_PREREQ
-#ifdef _MSC_VER
-#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
-
-// We require at least MSVC 2015.
-#if !LLVM_MSC_PREREQ(1900)
-#error wpiutil requires at least MSVC 2015.
-#endif
-
-#else
-#define LLVM_MSC_PREREQ(version) 0
-#endif
-#endif
-
-/// Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else.
-#ifndef LLVM_HAS_RVALUE_REFERENCE_THIS
-#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1)
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
-#else
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
-#endif
-#endif
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#ifndef LLVM_LVALUE_FUNCTION
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
-#endif
-#endif
-
-#ifndef LLVM_PREFETCH
-#if defined(__GNUC__)
-#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
-#else
-#define LLVM_PREFETCH(addr, rw, locality)
-#endif
-#endif
-
-#ifndef LLVM_ATTRIBUTE_USED
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-#endif
-
-/// LLVM_NODISCARD - Warn if a type or return value is discarded.
-#ifndef LLVM_NODISCARD
-#if __cplusplus > 201402L && __has_cpp_attribute(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-// Detect MSVC directly, since __cplusplus still defaults to old version
-#elif _MSVC_LANG >= 201703L
-#define LLVM_NODISCARD [[nodiscard]]
-#elif _MSC_VER
-#define LLVM_NODISCARD
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_NODISCARD
-#elif __has_cpp_attribute(clang::warn_unused_result)
-#define LLVM_NODISCARD [[clang::warn_unused_result]]
-#else
-#define LLVM_NODISCARD
-#endif
-#endif
-
-// Some compilers warn about unused functions. When a function is sometimes
-// used or not depending on build settings (e.g. a function only called from
-// within "assert"), this attribute can be used to suppress such warnings.
-//
-// However, it shouldn't be used for unused *variables*, as those have a much
-// more portable solution:
-//   (void)unused_var_name;
-// Prefer cast-to-void wherever it is sufficient.
-#ifndef LLVM_ATTRIBUTE_UNUSED
-#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define LLVM_ATTRIBUTE_UNUSED
-#endif
-#endif
-
-#ifndef LLVM_READNONE
-// Prior to clang 3.2, clang did not accept any spelling of
-// __has_attribute(const), so assume it is supported.
-#if defined(__clang__) || defined(__GNUC__)
-// aka 'CONST' but following LLVM Conventions.
-#define LLVM_READNONE __attribute__((__const__))
-#else
-#define LLVM_READNONE
-#endif
-#endif
-
-#ifndef LLVM_READONLY
-#if __has_attribute(pure) || defined(__GNUC__)
-// aka 'PURE' but following LLVM Conventions.
-#define LLVM_READONLY __attribute__((__pure__))
-#else
-#define LLVM_READONLY
-#endif
-#endif
-
-#ifndef LLVM_LIKELY
-#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
-#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
-#else
-#define LLVM_LIKELY(EXPR) (EXPR)
-#define LLVM_UNLIKELY(EXPR) (EXPR)
-#endif
-#endif
-
-/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#ifndef LLVM_ATTRIBUTE_NOINLINE
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
-#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define LLVM_ATTRIBUTE_NOINLINE
-#endif
-#endif
-
-/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#ifndef LLVM_ATTRIBUTE_ALWAYS_INLINE
-#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline)) inline
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
-#endif
-#endif
-
-#ifndef LLVM_ATTRIBUTE_NORETURN
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define LLVM_ATTRIBUTE_NORETURN
-#endif
-#endif
-
-#ifndef LLVM_ATTRIBUTE_RETURNS_NONNULL
-#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL
-#endif
-#endif
-
-/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
-/// pointer that does not alias any other valid pointer.
-#ifndef LLVM_ATTRIBUTE_RETURNS_NOALIAS
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
-#endif
-#endif
-
-/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#ifndef LLVM_FALLTHROUGH
-#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
-#define LLVM_FALLTHROUGH [[fallthrough]]
-// Detect MSVC directly, since __cplusplus still defaults to old version
-#elif _MSVC_LANG >= 201703L
-#define LLVM_FALLTHROUGH [[fallthrough]]
-#elif _MSC_VER
-#define LLVM_FALLTHROUGH
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_FALLTHROUGH
-#elif __has_cpp_attribute(clang::fallthrough)
-#define LLVM_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define LLVM_FALLTHROUGH
-#endif
-#endif
-
-/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
-/// pedantic diagnostics.
-#ifndef LLVM_EXTENSION
-#ifdef __GNUC__
-#define LLVM_EXTENSION __extension__
-#else
-#define LLVM_EXTENSION
-#endif
-#endif
-
-// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-#ifndef LLVM_ATTRIBUTE_DEPRECATED
-#if __has_feature(attribute_deprecated_with_message)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated(message)))
-#elif defined(__GNUC__)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  __declspec(deprecated(message)) decl
-#else
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl
-#endif
-#endif
-
-/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
-/// to an expression which states that it is undefined behavior for the
-/// compiler to reach this point.  Otherwise is not defined.
-#ifndef LLVM_BUILTIN_UNREACHABLE
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
-# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-# define LLVM_BUILTIN_UNREACHABLE __assume(false)
-#endif
-#endif
-
-/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
-/// which causes the program to exit abnormally.
-#ifndef LLVM_BUILTIN_TRAP
-#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
-# define LLVM_BUILTIN_TRAP __builtin_trap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC, does not require forward
-// declarations involving platform-specific typedefs (unlike RaiseException),
-// results in a call to vectored exception handlers, and encodes to a short
-// instruction that still causes the trapping behavior we want.
-# define LLVM_BUILTIN_TRAP __debugbreak()
-#else
-# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
-#endif
-#endif
-
-/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
-/// an expression which causes the program to break while running
-/// under a debugger.
-#ifndef LLVM_BUILTIN_DEBUGTRAP
-#if __has_builtin(__builtin_debugtrap)
-# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC and breaks while
-// running under the debugger, and also supports invoking a debugger
-// when the OS is configured appropriately.
-# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
-#else
-// Just continue execution when built with compilers that have no
-// support. This is a debugging aid and not intended to force the
-// program to abort if encountered.
-# define LLVM_BUILTIN_DEBUGTRAP
-#endif
-#endif
-
-/// \macro LLVM_ASSUME_ALIGNED
-/// Returns a pointer with an assumed alignment.
-#ifndef LLVM_ASSUME_ALIGNED
-#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
-# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
-#elif defined(LLVM_BUILTIN_UNREACHABLE)
-// As of today, clang does not support __builtin_assume_aligned.
-# define LLVM_ASSUME_ALIGNED(p, a) \
-           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
-#else
-# define LLVM_ASSUME_ALIGNED(p, a) (p)
-#endif
-#endif
-
-/// \macro LLVM_ALIGNAS
-/// Used to specify a minimum alignment for a structure or variable.
-#ifndef LLVM_ALIGNAS
-#if __GNUC__ && !__has_feature(cxx_alignas) && !LLVM_GNUC_PREREQ(4, 8, 1)
-# define LLVM_ALIGNAS(x) __attribute__((aligned(x)))
-#else
-# define LLVM_ALIGNAS(x) alignas(x)
-#endif
-#endif
-
-/// \macro LLVM_PACKED
-/// Used to specify a packed structure.
-/// LLVM_PACKED(
-///    struct A {
-///      int i;
-///      int j;
-///      int k;
-///      long long l;
-///   });
-///
-/// LLVM_PACKED_START
-/// struct B {
-///   int i;
-///   int j;
-///   int k;
-///   long long l;
-/// };
-/// LLVM_PACKED_END
-#ifndef LLVM_PACKED
-#ifdef _MSC_VER
-# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
-# define LLVM_PACKED_START __pragma(pack(push, 1))
-# define LLVM_PACKED_END   __pragma(pack(pop))
-#else
-# define LLVM_PACKED(d) d __attribute__((packed))
-# define LLVM_PACKED_START _Pragma("pack(push, 1)")
-# define LLVM_PACKED_END   _Pragma("pack(pop)")
-#endif
-#endif
-
-/// \macro LLVM_PTR_SIZE
-/// A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with LLVM_ALIGNAS or when doing computation in
-/// the preprocessor.
-#ifndef LLVM_PTR_SIZE
-#ifdef __SIZEOF_POINTER__
-# define LLVM_PTR_SIZE __SIZEOF_POINTER__
-#elif defined(_WIN64)
-# define LLVM_PTR_SIZE 8
-#elif defined(_WIN32)
-# define LLVM_PTR_SIZE 4
-#elif defined(_MSC_VER)
-# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
-#else
-# define LLVM_PTR_SIZE sizeof(void *)
-#endif
-#endif
-
-/// \macro LLVM_NO_SANITIZE
-/// Disable a particular sanitizer for a function.
-#ifndef LLVM_NO_SANITIZE
-#if __has_attribute(no_sanitize)
-#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
-#else
-#define LLVM_NO_SANITIZE(KIND)
-#endif
-#endif
-
-/// Mark debug helper function definitions like dump() that should not be
-/// stripped from debug builds.
-/// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
-// FIXME: Move this to a private config.h as it's not usable in public headers.
-#ifndef LLVM_DUMP_METHOD
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-#endif
-
-/// \macro LLVM_PRETTY_FUNCTION
-/// Gets a user-friendly looking function signature for the current scope
-/// using the best available method on each platform.  The exact format of the
-/// resulting string is implementation specific and non-portable, so this should
-/// only be used, for example, for logging or diagnostics.
-#ifndef LLVM_PRETTY_FUNCTION
-#if defined(_MSC_VER)
-#define LLVM_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__) || defined(__clang__)
-#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#define LLVM_PRETTY_FUNCTION __func__
-#endif
-#endif
-
-/// \macro LLVM_THREAD_LOCAL
-/// A thread-local storage specifier which can be used with globals,
-/// extern globals, and static globals.
-///
-/// This is essentially an extremely restricted analog to C++11's thread_local
-/// support, and uses that when available. However, it falls back on
-/// platform-specific or vendor-provided extensions when necessary. These
-/// extensions don't support many of the C++11 thread_local's features. You
-/// should only use this for PODs that you can statically initialize to
-/// some constant value. In almost all circumstances this is most appropriate
-/// for use with a pointer, integer, or small aggregation of pointers and
-/// integers.
-#ifndef LLVM_THREAD_LOCAL
-#if __has_feature(cxx_thread_local)
-#define LLVM_THREAD_LOCAL thread_local
-#elif defined(_MSC_VER)
-// MSVC supports this with a __declspec.
-#define LLVM_THREAD_LOCAL __declspec(thread)
-#else
-// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
-// we only need the restricted functionality that provides.
-#define LLVM_THREAD_LOCAL __thread
-#endif
-#endif
-
-namespace wpi {
-
-/// Allocate a buffer of memory with the given size and alignment.
-///
-/// When the compiler supports aligned operator new, this will use it to to
-/// handle even over-aligned allocations.
-///
-/// However, this doesn't make any attempt to leverage the fancier techniques
-/// like posix_memalign due to portability. It is mostly intended to allow
-/// compatibility with platforms that, after aligned allocation was added, use
-/// reduced default alignment.
-inline void *allocate_buffer(size_t Size, size_t Alignment) {
-  return ::operator new(Size
-#ifdef __cpp_aligned_new
-                        ,
-                        std::align_val_t(Alignment)
-#endif
-  );
-}
-
-/// Deallocate a buffer of memory with the given size and alignment.
-///
-/// If supported, this will used the sized delete operator. Also if supported,
-/// this will pass the alignment to the delete operator.
-///
-/// The pointer must have been allocated with the corresponding new operator,
-/// most likely using the above helper.
-inline void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment) {
-  ::operator delete(Ptr
-#ifdef __cpp_sized_deallocation
-                    ,
-                    Size
-#endif
-#ifdef __cpp_aligned_new
-                    ,
-                    std::align_val_t(Alignment)
-#endif
-  );
-}
-
-} // End namespace wpi
-
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/DataLog.h b/wpiutil/src/main/native/include/wpi/DataLog.h
new file mode 100644
index 0000000..cac273c
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/DataLog.h
@@ -0,0 +1,696 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <span>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <vector>
+
+#include "wpi/DenseMap.h"
+#include "wpi/StringMap.h"
+#include "wpi/condition_variable.h"
+#include "wpi/mutex.h"
+
+namespace wpi {
+class Logger;
+}  // namespace wpi
+
+namespace wpi::log {
+
+namespace impl {
+
+enum ControlRecordType {
+  kControlStart = 0,
+  kControlFinish,
+  kControlSetMetadata
+};
+
+}  // namespace impl
+
+/**
+ * A data log. The log file is created immediately upon construction with a
+ * temporary filename.  The file may be renamed at any time using the
+ * SetFilename() function.
+ *
+ * The lifetime of the data log object must be longer than any data log entry
+ * objects that refer to it.
+ *
+ * The data log is periodically flushed to disk.  It can also be explicitly
+ * flushed to disk by using the Flush() function.
+ *
+ * Finish() is needed only to indicate in the log that a particular entry is
+ * no longer being used (it releases the name to ID mapping).  Finish() is not
+ * required to be called for data to be flushed to disk; entries in the log
+ * are written as Append() calls are being made.  In fact, Finish() does not
+ * need to be called at all; this is helpful to avoid shutdown races where the
+ * DataLog object might be destroyed before other objects.  It's often not a
+ * good idea to call Finish() from destructors for this reason.
+ *
+ * DataLog calls are thread safe.  DataLog uses a typical multiple-supplier,
+ * single-consumer setup.  Writes to the log are atomic, but there is no
+ * guaranteed order in the log when multiple threads are writing to it;
+ * whichever thread grabs the write mutex first will get written first.
+ * For this reason (as well as the fact that timestamps can be set to
+ * arbitrary values), records in the log are not guaranteed to be sorted by
+ * timestamp.
+ */
+class DataLog final {
+ public:
+  /**
+   * Construct a new Data Log.  The log will be initially created with a
+   * temporary filename.
+   *
+   * @param dir directory to store the log
+   * @param filename filename to use; if none provided, a random filename is
+   *                 generated of the form "wpilog_{}.wpilog"
+   * @param period time between automatic flushes to disk, in seconds;
+   *               this is a time/storage tradeoff
+   * @param extraHeader extra header data
+   */
+  explicit DataLog(std::string_view dir = "", std::string_view filename = "",
+                   double period = 0.25, std::string_view extraHeader = "");
+
+  /**
+   * Construct a new Data Log.  The log will be initially created with a
+   * temporary filename.
+   *
+   * @param msglog message logger (will be called from separate thread)
+   * @param dir directory to store the log
+   * @param filename filename to use; if none provided, a random filename is
+   *                 generated of the form "wpilog_{}.wpilog"
+   * @param period time between automatic flushes to disk, in seconds;
+   *               this is a time/storage tradeoff
+   * @param extraHeader extra header data
+   */
+  explicit DataLog(wpi::Logger& msglog, std::string_view dir = "",
+                   std::string_view filename = "", double period = 0.25,
+                   std::string_view extraHeader = "");
+
+  /**
+   * Construct a new Data Log that passes its output to the provided function
+   * rather than a file.  The write function will be called on a separate
+   * background thread and may block.  The write function is called with an
+   * empty data array when the thread is terminating.
+   *
+   * @param write write function
+   * @param period time between automatic calls to write, in seconds;
+   *               this is a time/storage tradeoff
+   * @param extraHeader extra header data
+   */
+  explicit DataLog(std::function<void(std::span<const uint8_t> data)> write,
+                   double period = 0.25, std::string_view extraHeader = "");
+
+  /**
+   * Construct a new Data Log that passes its output to the provided function
+   * rather than a file.  The write function will be called on a separate
+   * background thread and may block.  The write function is called with an
+   * empty data array when the thread is terminating.
+   *
+   * @param msglog message logger (will be called from separate thread)
+   * @param write write function
+   * @param period time between automatic calls to write, in seconds;
+   *               this is a time/storage tradeoff
+   * @param extraHeader extra header data
+   */
+  explicit DataLog(wpi::Logger& msglog,
+                   std::function<void(std::span<const uint8_t> data)> write,
+                   double period = 0.25, std::string_view extraHeader = "");
+
+  ~DataLog();
+  DataLog(const DataLog&) = delete;
+  DataLog& operator=(const DataLog&) = delete;
+  DataLog(DataLog&&) = delete;
+  DataLog& operator=(const DataLog&&) = delete;
+
+  /**
+   * Change log filename.
+   *
+   * @param filename filename
+   */
+  void SetFilename(std::string_view filename);
+
+  /**
+   * Explicitly flushes the log data to disk.
+   */
+  void Flush();
+
+  /**
+   * Pauses appending of data records to the log.  While paused, no data records
+   * are saved (e.g. AppendX is a no-op).  Has no effect on entry starts /
+   * finishes / metadata changes.
+   */
+  void Pause();
+
+  /**
+   * Resumes appending of data records to the log.
+   */
+  void Resume();
+
+  /**
+   * Start an entry.  Duplicate names are allowed (with the same type), and
+   * result in the same index being returned (Start/Finish are reference
+   * counted).  A duplicate name with a different type will result in an error
+   * message being printed to the console and 0 being returned (which will be
+   * ignored by the Append functions).
+   *
+   * @param name Name
+   * @param type Data type
+   * @param metadata Initial metadata (e.g. data properties)
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   *
+   * @return Entry index
+   */
+  int Start(std::string_view name, std::string_view type,
+            std::string_view metadata = {}, int64_t timestamp = 0);
+
+  /**
+   * Finish an entry.
+   *
+   * @param entry Entry index
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Finish(int entry, int64_t timestamp = 0);
+
+  /**
+   * Updates the metadata for an entry.
+   *
+   * @param entry Entry index
+   * @param metadata New metadata for the entry
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void SetMetadata(int entry, std::string_view metadata, int64_t timestamp = 0);
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param entry Entry index, as returned by Start()
+   * @param data Data to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void AppendRaw(int entry, std::span<const uint8_t> data, int64_t timestamp);
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param entry Entry index, as returned by Start()
+   * @param data Data to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void AppendRaw2(int entry, std::span<const std::span<const uint8_t>> data,
+                  int64_t timestamp);
+
+  void AppendBoolean(int entry, bool value, int64_t timestamp);
+  void AppendInteger(int entry, int64_t value, int64_t timestamp);
+  void AppendFloat(int entry, float value, int64_t timestamp);
+  void AppendDouble(int entry, double value, int64_t timestamp);
+  void AppendString(int entry, std::string_view value, int64_t timestamp);
+  void AppendBooleanArray(int entry, std::span<const bool> arr,
+                          int64_t timestamp);
+  void AppendBooleanArray(int entry, std::span<const int> arr,
+                          int64_t timestamp);
+  void AppendBooleanArray(int entry, std::span<const uint8_t> arr,
+                          int64_t timestamp);
+  void AppendIntegerArray(int entry, std::span<const int64_t> arr,
+                          int64_t timestamp);
+  void AppendFloatArray(int entry, std::span<const float> arr,
+                        int64_t timestamp);
+  void AppendDoubleArray(int entry, std::span<const double> arr,
+                         int64_t timestamp);
+  void AppendStringArray(int entry, std::span<const std::string> arr,
+                         int64_t timestamp);
+  void AppendStringArray(int entry, std::span<const std::string_view> arr,
+                         int64_t timestamp);
+
+ private:
+  void WriterThreadMain(std::string_view dir);
+  void WriterThreadMain(
+      std::function<void(std::span<const uint8_t> data)> write);
+
+  // must be called with m_mutex held
+  uint8_t* StartRecord(uint32_t entry, uint64_t timestamp, uint32_t payloadSize,
+                       size_t reserveSize);
+  uint8_t* Reserve(size_t size);
+  void AppendImpl(std::span<const uint8_t> data);
+  void AppendStringImpl(std::string_view str);
+
+  wpi::Logger& m_msglog;
+  mutable wpi::mutex m_mutex;
+  wpi::condition_variable m_cond;
+  bool m_active{true};
+  bool m_doFlush{false};
+  bool m_paused{false};
+  double m_period;
+  std::string m_extraHeader;
+  std::string m_newFilename;
+  class Buffer;
+  std::vector<Buffer> m_free;
+  std::vector<Buffer> m_outgoing;
+  struct EntryInfo {
+    std::string type;
+    int id{0};
+  };
+  wpi::StringMap<EntryInfo> m_entries;
+  wpi::DenseMap<int, unsigned int> m_entryCounts;
+  int m_lastId = 0;
+  std::thread m_thread;
+};
+
+/**
+ * Log entry base class.
+ */
+class DataLogEntry {
+ protected:
+  DataLogEntry() = default;
+  DataLogEntry(DataLog& log, std::string_view name, std::string_view type,
+               std::string_view metadata = {}, int64_t timestamp = 0)
+      : m_log{&log}, m_entry{log.Start(name, type, metadata, timestamp)} {}
+
+ public:
+  DataLogEntry(const DataLogEntry&) = delete;
+  DataLogEntry& operator=(const DataLogEntry&) = delete;
+
+  DataLogEntry(DataLogEntry&& rhs) : m_log{rhs.m_log}, m_entry{rhs.m_entry} {
+    rhs.m_log = nullptr;
+  }
+  DataLogEntry& operator=(DataLogEntry&& rhs) {
+    if (m_log) {
+      m_log->Finish(m_entry);
+    }
+    m_log = rhs.m_log;
+    rhs.m_log = nullptr;
+    m_entry = rhs.m_entry;
+    return *this;
+  }
+
+  explicit operator bool() const { return m_log != nullptr; }
+
+  /**
+   * Updates the metadata for the entry.
+   *
+   * @param metadata New metadata for the entry
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void SetMetadata(std::string_view metadata, int64_t timestamp = 0) {
+    m_log->SetMetadata(m_entry, metadata, timestamp);
+  }
+
+  /**
+   * Finishes the entry.
+   *
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Finish(int64_t timestamp = 0) { m_log->Finish(m_entry, timestamp); }
+
+ protected:
+  DataLog* m_log = nullptr;
+  int m_entry = 0;
+};
+
+/**
+ * Log arbitrary byte data.
+ */
+class RawLogEntry : public DataLogEntry {
+ public:
+  static constexpr std::string_view kDataType = "raw";
+
+  RawLogEntry() = default;
+  RawLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : RawLogEntry{log, name, {}, kDataType, timestamp} {}
+  RawLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+              int64_t timestamp = 0)
+      : RawLogEntry{log, name, metadata, kDataType, timestamp} {}
+  RawLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+              std::string_view type, int64_t timestamp = 0)
+      : DataLogEntry{log, name, type, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param data Data to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const uint8_t> data, int64_t timestamp = 0) {
+    m_log->AppendRaw(m_entry, data, timestamp);
+  }
+};
+
+/**
+ * Log boolean values.
+ */
+class BooleanLogEntry : public DataLogEntry {
+ public:
+  static constexpr std::string_view kDataType = "boolean";
+
+  BooleanLogEntry() = default;
+  BooleanLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : BooleanLogEntry{log, name, {}, timestamp} {}
+  BooleanLogEntry(DataLog& log, std::string_view name,
+                  std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(bool value, int64_t timestamp = 0) {
+    m_log->AppendBoolean(m_entry, value, timestamp);
+  }
+};
+
+/**
+ * Log integer values.
+ */
+class IntegerLogEntry : public DataLogEntry {
+ public:
+  static constexpr std::string_view kDataType = "int64";
+
+  IntegerLogEntry() = default;
+  IntegerLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : IntegerLogEntry{log, name, {}, timestamp} {}
+  IntegerLogEntry(DataLog& log, std::string_view name,
+                  std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(int64_t value, int64_t timestamp = 0) {
+    m_log->AppendInteger(m_entry, value, timestamp);
+  }
+};
+
+/**
+ * Log float values.
+ */
+class FloatLogEntry : public DataLogEntry {
+ public:
+  static constexpr std::string_view kDataType = "float";
+
+  FloatLogEntry() = default;
+  FloatLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : FloatLogEntry{log, name, {}, timestamp} {}
+  FloatLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+                int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(float value, int64_t timestamp = 0) {
+    m_log->AppendFloat(m_entry, value, timestamp);
+  }
+};
+
+/**
+ * Log double values.
+ */
+class DoubleLogEntry : public DataLogEntry {
+ public:
+  static constexpr std::string_view kDataType = "double";
+
+  DoubleLogEntry() = default;
+  DoubleLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : DoubleLogEntry{log, name, {}, timestamp} {}
+  DoubleLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+                 int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(double value, int64_t timestamp = 0) {
+    m_log->AppendDouble(m_entry, value, timestamp);
+  }
+};
+
+/**
+ * Log string values.
+ */
+class StringLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "string";
+
+  StringLogEntry() = default;
+  StringLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : StringLogEntry{log, name, {}, kDataType, timestamp} {}
+  StringLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+                 int64_t timestamp = 0)
+      : StringLogEntry{log, name, metadata, kDataType, timestamp} {}
+  StringLogEntry(DataLog& log, std::string_view name, std::string_view metadata,
+                 std::string_view type, int64_t timestamp = 0)
+      : DataLogEntry{log, name, type, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param value Value to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::string_view value, int64_t timestamp = 0) {
+    m_log->AppendString(m_entry, value, timestamp);
+  }
+};
+
+/**
+ * Log array of boolean values.
+ */
+class BooleanArrayLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "boolean[]";
+
+  BooleanArrayLogEntry() = default;
+  BooleanArrayLogEntry(DataLog& log, std::string_view name,
+                       int64_t timestamp = 0)
+      : BooleanArrayLogEntry{log, name, {}, timestamp} {}
+  BooleanArrayLogEntry(DataLog& log, std::string_view name,
+                       std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.  For find functions to work, timestamp
+   * must be monotonically increasing.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const bool> arr, int64_t timestamp = 0) {
+    m_log->AppendBooleanArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<bool> arr, int64_t timestamp = 0) {
+    Append(std::span{arr.begin(), arr.end()}, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const int> arr, int64_t timestamp = 0) {
+    m_log->AppendBooleanArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<int> arr, int64_t timestamp = 0) {
+    Append(std::span{arr.begin(), arr.end()}, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const uint8_t> arr, int64_t timestamp = 0) {
+    m_log->AppendBooleanArray(m_entry, arr, timestamp);
+  }
+};
+
+/**
+ * Log array of integer values.
+ */
+class IntegerArrayLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "int64[]";
+
+  IntegerArrayLogEntry() = default;
+  IntegerArrayLogEntry(DataLog& log, std::string_view name,
+                       int64_t timestamp = 0)
+      : IntegerArrayLogEntry{log, name, {}, timestamp} {}
+  IntegerArrayLogEntry(DataLog& log, std::string_view name,
+                       std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const int64_t> arr, int64_t timestamp = 0) {
+    m_log->AppendIntegerArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<int64_t> arr, int64_t timestamp = 0) {
+    Append({arr.begin(), arr.end()}, timestamp);
+  }
+};
+
+/**
+ * Log array of float values.
+ */
+class FloatArrayLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "float[]";
+
+  FloatArrayLogEntry() = default;
+  FloatArrayLogEntry(DataLog& log, std::string_view name, int64_t timestamp = 0)
+      : FloatArrayLogEntry{log, name, {}, timestamp} {}
+  FloatArrayLogEntry(DataLog& log, std::string_view name,
+                     std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const float> arr, int64_t timestamp = 0) {
+    m_log->AppendFloatArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<float> arr, int64_t timestamp = 0) {
+    Append({arr.begin(), arr.end()}, timestamp);
+  }
+};
+
+/**
+ * Log array of double values.
+ */
+class DoubleArrayLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "double[]";
+
+  DoubleArrayLogEntry() = default;
+  DoubleArrayLogEntry(DataLog& log, std::string_view name,
+                      int64_t timestamp = 0)
+      : DoubleArrayLogEntry{log, name, {}, timestamp} {}
+  DoubleArrayLogEntry(DataLog& log, std::string_view name,
+                      std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const double> arr, int64_t timestamp = 0) {
+    m_log->AppendDoubleArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<double> arr, int64_t timestamp = 0) {
+    Append({arr.begin(), arr.end()}, timestamp);
+  }
+};
+
+/**
+ * Log array of string values.
+ */
+class StringArrayLogEntry : public DataLogEntry {
+ public:
+  static constexpr const char* kDataType = "string[]";
+
+  StringArrayLogEntry() = default;
+  StringArrayLogEntry(DataLog& log, std::string_view name,
+                      int64_t timestamp = 0)
+      : StringArrayLogEntry{log, name, {}, timestamp} {}
+  StringArrayLogEntry(DataLog& log, std::string_view name,
+                      std::string_view metadata, int64_t timestamp = 0)
+      : DataLogEntry{log, name, kDataType, metadata, timestamp} {}
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const std::string> arr, int64_t timestamp = 0) {
+    m_log->AppendStringArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::span<const std::string_view> arr, int64_t timestamp = 0) {
+    m_log->AppendStringArray(m_entry, arr, timestamp);
+  }
+
+  /**
+   * Appends a record to the log.
+   *
+   * @param arr Values to record
+   * @param timestamp Time stamp (may be 0 to indicate now)
+   */
+  void Append(std::initializer_list<std::string_view> arr,
+              int64_t timestamp = 0) {
+    Append(std::span<const std::string_view>{arr.begin(), arr.end()},
+           timestamp);
+  }
+};
+
+}  // namespace wpi::log
diff --git a/wpiutil/src/main/native/include/wpi/DataLogReader.h b/wpiutil/src/main/native/include/wpi/DataLogReader.h
new file mode 100644
index 0000000..b1153e4
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/DataLogReader.h
@@ -0,0 +1,369 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <iterator>
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+
+#include "wpi/MemoryBuffer.h"
+
+namespace wpi::log {
+
+/**
+ * Data contained in a start control record as created by DataLog::Start() when
+ * writing the log. This can be read by calling DataLogRecord::GetStartData().
+ */
+struct StartRecordData {
+  /** Entry ID; this will be used for this entry in future records. */
+  int entry;
+
+  /** Entry name. */
+  std::string_view name;
+
+  /** Type of the stored data for this entry, as a string, e.g. "double". */
+  std::string_view type;
+
+  /** Initial metadata. */
+  std::string_view metadata;
+};
+
+/**
+ * Data contained in a set metadata control record as created by
+ * DataLog::SetMetadata(). This can be read by calling
+ * DataLogRecord::GetSetMetadataData().
+ */
+struct MetadataRecordData {
+  /** Entry ID. */
+  int entry;
+
+  /** New metadata for the entry. */
+  std::string_view metadata;
+};
+
+/**
+ * A record in the data log. May represent either a control record (entry == 0)
+ * or a data record. Used only for reading (e.g. with DataLogReader).
+ */
+class DataLogRecord {
+ public:
+  DataLogRecord() = default;
+  DataLogRecord(int entry, int64_t timestamp, std::span<const uint8_t> data)
+      : m_timestamp{timestamp}, m_data{data}, m_entry{entry} {}
+
+  /**
+   * Gets the entry ID.
+   *
+   * @return entry ID
+   */
+  int GetEntry() const { return m_entry; }
+
+  /**
+   * Gets the record timestamp.
+   *
+   * @return Timestamp, in integer microseconds
+   */
+  int64_t GetTimestamp() const { return m_timestamp; }
+
+  /**
+   * Gets the size of the raw data.
+   *
+   * @return size
+   */
+  size_t GetSize() const { return m_data.size(); }
+
+  /**
+   * Gets the raw data. Use the GetX functions to decode based on the data type
+   * in the entry's start record.
+   */
+  std::span<const uint8_t> GetRaw() const { return m_data; }
+
+  /**
+   * Returns true if the record is a control record.
+   *
+   * @return True if control record, false if normal data record.
+   */
+  bool IsControl() const { return m_entry == 0; }
+
+  /**
+   * Returns true if the record is a start control record. Use GetStartData()
+   * to decode the contents.
+   *
+   * @return True if start control record, false otherwise.
+   */
+  bool IsStart() const;
+
+  /**
+   * Returns true if the record is a finish control record. Use GetFinishEntry()
+   * to decode the contents.
+   *
+   * @return True if finish control record, false otherwise.
+   */
+  bool IsFinish() const;
+
+  /**
+   * Returns true if the record is a set metadata control record. Use
+   * GetSetMetadataData() to decode the contents.
+   *
+   * @return True if set metadata control record, false otherwise.
+   */
+  bool IsSetMetadata() const;
+
+  /**
+   * Decodes a start control record.
+   *
+   * @param[out] out start record decoded data (if successful)
+   * @return True on success, false on error
+   */
+  bool GetStartData(StartRecordData* out) const;
+
+  /**
+   * Decodes a finish control record.
+   *
+   * @param[out] out finish record entry ID (if successful)
+   * @return True on success, false on error
+   */
+  bool GetFinishEntry(int* out) const;
+
+  /**
+   * Decodes a set metadata control record.
+   *
+   * @param[out] out set metadata record decoded data (if successful)
+   * @return True on success, false on error
+   */
+  bool GetSetMetadataData(MetadataRecordData* out) const;
+
+  /**
+   * Decodes a data record as a boolean. Note if the data type (as indicated in
+   * the corresponding start control record for this entry) is not "boolean",
+   * invalid results may be returned.
+   *
+   * @param[out] value boolean value (if successful)
+   * @return True on success, false on error
+   */
+  bool GetBoolean(bool* value) const;
+
+  /**
+   * Decodes a data record as an integer. Note if the data type (as indicated in
+   * the corresponding start control record for this entry) is not "int64",
+   * invalid results may be returned.
+   *
+   * @param[out] value integer value (if successful)
+   * @return True on success, false on error
+   */
+  bool GetInteger(int64_t* value) const;
+
+  /**
+   * Decodes a data record as a float. Note if the data type (as indicated in
+   * the corresponding start control record for this entry) is not "float",
+   * invalid results may be returned.
+   *
+   * @param[out] value float value (if successful)
+   * @return True on success, false on error
+   */
+  bool GetFloat(float* value) const;
+
+  /**
+   * Decodes a data record as a double. Note if the data type (as indicated in
+   * the corresponding start control record for this entry) is not "double",
+   * invalid results may be returned.
+   *
+   * @param[out] value double value (if successful)
+   * @return True on success, false on error
+   */
+  bool GetDouble(double* value) const;
+
+  /**
+   * Decodes a data record as a string. Note if the data type (as indicated in
+   * the corresponding start control record for this entry) is not "string",
+   * invalid results may be returned.
+   *
+   * @param[out] value string value
+   * @return True (never fails)
+   */
+  bool GetString(std::string_view* value) const;
+
+  /**
+   * Decodes a data record as a boolean array. Note if the data type (as
+   * indicated in the corresponding start control record for this entry) is not
+   * "boolean[]", invalid results may be returned.
+   *
+   * @param[out] arr boolean array
+   * @return True (never fails)
+   */
+  bool GetBooleanArray(std::vector<int>* arr) const;
+
+  /**
+   * Decodes a data record as an integer array. Note if the data type (as
+   * indicated in the corresponding start control record for this entry) is not
+   * "int64[]", invalid results may be returned.
+   *
+   * @param[out] arr integer array (if successful)
+   * @return True on success, false on error
+   */
+  bool GetIntegerArray(std::vector<int64_t>* arr) const;
+
+  /**
+   * Decodes a data record as a float array. Note if the data type (as
+   * indicated in the corresponding start control record for this entry) is not
+   * "float[]", invalid results may be returned.
+   *
+   * @param[out] arr float array (if successful)
+   * @return True on success, false on error
+   */
+  bool GetFloatArray(std::vector<float>* arr) const;
+
+  /**
+   * Decodes a data record as a double array. Note if the data type (as
+   * indicated in the corresponding start control record for this entry) is not
+   * "double[]", invalid results may be returned.
+   *
+   * @param[out] arr double array (if successful)
+   * @return True on success, false on error
+   */
+  bool GetDoubleArray(std::vector<double>* arr) const;
+
+  /**
+   * Decodes a data record as a string array. Note if the data type (as
+   * indicated in the corresponding start control record for this entry) is not
+   * "string[]", invalid results may be returned.
+   *
+   * @param[out] arr string array (if successful)
+   * @return True on success, false on error
+   */
+  bool GetStringArray(std::vector<std::string_view>* arr) const;
+
+ private:
+  int64_t m_timestamp{0};
+  std::span<const uint8_t> m_data;
+  int m_entry{-1};
+};
+
+class DataLogReader;
+
+/** DataLogReader iterator. */
+class DataLogIterator {
+ public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = DataLogRecord;
+  using pointer = const value_type*;
+  using reference = const value_type&;
+
+  DataLogIterator(const DataLogReader* reader, size_t pos)
+      : m_reader{reader}, m_pos{pos} {}
+
+  bool operator==(const DataLogIterator& oth) const {
+    return m_reader == oth.m_reader && m_pos == oth.m_pos;
+  }
+  bool operator!=(const DataLogIterator& oth) const {
+    return !this->operator==(oth);
+  }
+
+  bool operator<(const DataLogIterator& oth) const { return m_pos < oth.m_pos; }
+  bool operator>(const DataLogIterator& oth) const {
+    return !this->operator<(oth) && !this->operator==(oth);
+  }
+  bool operator<=(const DataLogIterator& oth) const {
+    return !this->operator>(oth);
+  }
+  bool operator>=(const DataLogIterator& oth) const {
+    return !this->operator<(oth);
+  }
+
+  DataLogIterator& operator++();
+
+  DataLogIterator operator++(int) {
+    DataLogIterator tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  reference operator*() const;
+
+  pointer operator->() const { return &this->operator*(); }
+
+ private:
+  const DataLogReader* m_reader;
+  size_t m_pos;
+  mutable bool m_valid = false;
+  mutable DataLogRecord m_value;
+};
+
+/** Data log reader (reads logs written by the DataLog class). */
+class DataLogReader {
+  friend class DataLogIterator;
+
+ public:
+  using iterator = DataLogIterator;
+
+  /** Constructs from a memory buffer. */
+  explicit DataLogReader(std::unique_ptr<MemoryBuffer> buffer);
+
+  /** Returns true if the data log is valid (e.g. has a valid header). */
+  explicit operator bool() const { return IsValid(); }
+
+  /** Returns true if the data log is valid (e.g. has a valid header). */
+  bool IsValid() const;
+
+  /**
+   * Gets the data log version. Returns 0 if data log is invalid.
+   *
+   * @return Version number; most significant byte is major, least significant
+   *         is minor (so version 1.0 will be 0x0100)
+   */
+  uint16_t GetVersion() const;
+
+  /**
+   * Gets the extra header data.
+   *
+   * @return Extra header data
+   */
+  std::string_view GetExtraHeader() const;
+
+  /**
+   * Gets the buffer identifier, typically the filename.
+   *
+   * @return Identifier string
+   */
+  std::string_view GetBufferIdentifier() const {
+    return m_buf ? m_buf->GetBufferIdentifier() : "Invalid";
+  }
+
+  /** Returns iterator to first record. */
+  iterator begin() const;
+
+  /** Returns end iterator. */
+  iterator end() const { return DataLogIterator{this, SIZE_MAX}; }
+
+ private:
+  std::unique_ptr<MemoryBuffer> m_buf;
+
+  bool GetRecord(size_t* pos, DataLogRecord* out) const;
+  bool GetNextRecord(size_t* pos) const;
+};
+
+inline DataLogIterator& DataLogIterator::operator++() {
+  if (!m_reader->GetNextRecord(&m_pos)) {
+    m_pos = SIZE_MAX;
+  }
+  m_valid = false;
+  return *this;
+}
+
+inline DataLogIterator::reference DataLogIterator::operator*() const {
+  if (!m_valid) {
+    size_t pos = m_pos;
+    if (m_reader->GetRecord(&pos, &m_value)) {
+      m_valid = true;
+    }
+  }
+  return m_value;
+}
+
+}  // namespace wpi::log
diff --git a/wpiutil/src/main/native/include/wpi/DenseMapInfo.h b/wpiutil/src/main/native/include/wpi/DenseMapInfo.h
deleted file mode 100644
index b6525a3..0000000
--- a/wpiutil/src/main/native/include/wpi/DenseMapInfo.h
+++ /dev/null
@@ -1,274 +0,0 @@
-//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines DenseMapInfo traits for DenseMap.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_DENSEMAPINFO_H
-#define WPIUTIL_WPI_DENSEMAPINFO_H
-
-#include "wpi/Hashing.h"
-#include "wpi/PointerLikeTypeTraits.h"
-#include "wpi/span.h"
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <string_view>
-#include <utility>
-
-namespace wpi {
-
-template<typename T>
-struct DenseMapInfo {
-  //static inline T getEmptyKey();
-  //static inline T getTombstoneKey();
-  //static unsigned getHashValue(const T &Val);
-  //static bool isEqual(const T &LHS, const T &RHS);
-};
-
-// Provide DenseMapInfo for all pointers.
-template<typename T>
-struct DenseMapInfo<T*> {
-  static inline T* getEmptyKey() {
-    uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
-    return reinterpret_cast<T*>(Val);
-  }
-
-  static inline T* getTombstoneKey() {
-    uintptr_t Val = static_cast<uintptr_t>(-2);
-    Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
-    return reinterpret_cast<T*>(Val);
-  }
-
-  static unsigned getHashValue(const T *PtrVal) {
-    return (unsigned((uintptr_t)PtrVal) >> 4) ^
-           (unsigned((uintptr_t)PtrVal) >> 9);
-  }
-
-  static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
-};
-
-// Provide DenseMapInfo for chars.
-template<> struct DenseMapInfo<char> {
-  static inline char getEmptyKey() { return ~0; }
-  static inline char getTombstoneKey() { return ~0 - 1; }
-  static unsigned getHashValue(const char& Val) { return Val * 37U; }
-
-  static bool isEqual(const char &LHS, const char &RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for unsigned shorts.
-template <> struct DenseMapInfo<unsigned short> {
-  static inline unsigned short getEmptyKey() { return 0xFFFF; }
-  static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
-  static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
-
-  static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for unsigned ints.
-template<> struct DenseMapInfo<unsigned> {
-  static inline unsigned getEmptyKey() { return ~0U; }
-  static inline unsigned getTombstoneKey() { return ~0U - 1; }
-  static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
-
-  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for unsigned longs.
-template<> struct DenseMapInfo<unsigned long> {
-  static inline unsigned long getEmptyKey() { return ~0UL; }
-  static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
-
-  static unsigned getHashValue(const unsigned long& Val) {
-    return (unsigned)(Val * 37UL);
-  }
-
-  static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for unsigned long longs.
-template<> struct DenseMapInfo<unsigned long long> {
-  static inline unsigned long long getEmptyKey() { return ~0ULL; }
-  static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
-
-  static unsigned getHashValue(const unsigned long long& Val) {
-    return (unsigned)(Val * 37ULL);
-  }
-
-  static bool isEqual(const unsigned long long& LHS,
-                      const unsigned long long& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for shorts.
-template <> struct DenseMapInfo<short> {
-  static inline short getEmptyKey() { return 0x7FFF; }
-  static inline short getTombstoneKey() { return -0x7FFF - 1; }
-  static unsigned getHashValue(const short &Val) { return Val * 37U; }
-  static bool isEqual(const short &LHS, const short &RHS) { return LHS == RHS; }
-};
-
-// Provide DenseMapInfo for ints.
-template<> struct DenseMapInfo<int> {
-  static inline int getEmptyKey() { return 0x7fffffff; }
-  static inline int getTombstoneKey() { return -0x7fffffff - 1; }
-  static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
-
-  static bool isEqual(const int& LHS, const int& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for longs.
-template<> struct DenseMapInfo<long> {
-  static inline long getEmptyKey() {
-    return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
-  }
-
-  static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
-
-  static unsigned getHashValue(const long& Val) {
-    return (unsigned)(Val * 37UL);
-  }
-
-  static bool isEqual(const long& LHS, const long& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for long longs.
-template<> struct DenseMapInfo<long long> {
-  static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
-  static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
-
-  static unsigned getHashValue(const long long& Val) {
-    return (unsigned)(Val * 37ULL);
-  }
-
-  static bool isEqual(const long long& LHS,
-                      const long long& RHS) {
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for all pairs whose members have info.
-template<typename T, typename U>
-struct DenseMapInfo<std::pair<T, U>> {
-  using Pair = std::pair<T, U>;
-  using FirstInfo = DenseMapInfo<T>;
-  using SecondInfo = DenseMapInfo<U>;
-
-  static inline Pair getEmptyKey() {
-    return std::make_pair(FirstInfo::getEmptyKey(),
-                          SecondInfo::getEmptyKey());
-  }
-
-  static inline Pair getTombstoneKey() {
-    return std::make_pair(FirstInfo::getTombstoneKey(),
-                          SecondInfo::getTombstoneKey());
-  }
-
-  static unsigned getHashValue(const Pair& PairVal) {
-    uint64_t key = (uint64_t)FirstInfo::getHashValue(PairVal.first) << 32
-          | (uint64_t)SecondInfo::getHashValue(PairVal.second);
-    key += ~(key << 32);
-    key ^= (key >> 22);
-    key += ~(key << 13);
-    key ^= (key >> 8);
-    key += (key << 3);
-    key ^= (key >> 15);
-    key += ~(key << 27);
-    key ^= (key >> 31);
-    return (unsigned)key;
-  }
-
-  static bool isEqual(const Pair &LHS, const Pair &RHS) {
-    return FirstInfo::isEqual(LHS.first, RHS.first) &&
-           SecondInfo::isEqual(LHS.second, RHS.second);
-  }
-};
-
-// Provide DenseMapInfo for std::string_view.
-template <> struct DenseMapInfo<std::string_view> {
-  static inline std::string_view getEmptyKey() {
-    return std::string_view(reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)),
-                     0);
-  }
-
-  static inline std::string_view getTombstoneKey() {
-    return std::string_view(reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)),
-                     0);
-  }
-
-  static unsigned getHashValue(std::string_view Val) {
-    assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
-    assert(Val.data() != getTombstoneKey().data() &&
-           "Cannot hash the tombstone key!");
-    return (unsigned)(hash_value(Val));
-  }
-
-  static bool isEqual(std::string_view LHS, std::string_view RHS) {
-    if (RHS.data() == getEmptyKey().data())
-      return LHS.data() == getEmptyKey().data();
-    if (RHS.data() == getTombstoneKey().data())
-      return LHS.data() == getTombstoneKey().data();
-    return LHS == RHS;
-  }
-};
-
-// Provide DenseMapInfo for spans.
-template <typename T> struct DenseMapInfo<span<T>> {
-  static inline span<T> getEmptyKey() {
-    return span<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)),
-                   size_t(0));
-  }
-
-  static inline span<T> getTombstoneKey() {
-    return span<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)),
-                   size_t(0));
-  }
-
-  static unsigned getHashValue(span<T> Val) {
-    assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
-    assert(Val.data() != getTombstoneKey().data() &&
-           "Cannot hash the tombstone key!");
-    return (unsigned)(hash_value(Val));
-  }
-
-  static bool isEqual(span<T> LHS, span<T> RHS) {
-    if (RHS.data() == getEmptyKey().data())
-      return LHS.data() == getEmptyKey().data();
-    if (RHS.data() == getTombstoneKey().data())
-      return LHS.data() == getTombstoneKey().data();
-    return LHS == RHS;
-  }
-};
-
-template <> struct DenseMapInfo<hash_code> {
-  static inline hash_code getEmptyKey() { return hash_code(-1); }
-  static inline hash_code getTombstoneKey() { return hash_code(-2); }
-  static unsigned getHashValue(hash_code val) { return static_cast<unsigned>(val); }
-  static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
-};
-
-} // end namespace wpi
-
-#endif // LLVM_ADT_DENSEMAPINFO_H
diff --git a/wpiutil/src/main/native/include/wpi/DsClient.h b/wpiutil/src/main/native/include/wpi/DsClient.h
deleted file mode 100644
index c24ba3b..0000000
--- a/wpiutil/src/main/native/include/wpi/DsClient.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/Signal.h"
-
-namespace wpi {
-
-class Logger;
-
-namespace uv {
-class Loop;
-class Tcp;
-class Timer;
-}  // namespace uv
-
-class DsClient : public std::enable_shared_from_this<DsClient> {
-  struct private_init {};
-
- public:
-  static std::shared_ptr<DsClient> Create(wpi::uv::Loop& loop,
-                                          wpi::Logger& logger) {
-    return std::make_shared<DsClient>(loop, logger, private_init{});
-  }
-
-  DsClient(wpi::uv::Loop& loop, wpi::Logger& logger, const private_init&);
-  ~DsClient();
-  DsClient(const DsClient&) = delete;
-  DsClient& operator=(const DsClient&) = delete;
-
-  void Close();
-
-  sig::Signal<std::string_view> setIp;
-  sig::Signal<> clearIp;
-
- private:
-  void Connect();
-  void HandleIncoming(std::string_view in);
-  void ParseJson();
-
-  wpi::Logger& m_logger;
-
-  std::shared_ptr<wpi::uv::Tcp> m_tcp;
-  std::shared_ptr<wpi::uv::Timer> m_timer;
-
-  std::string m_json;
-};
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/EventLoopRunner.h b/wpiutil/src/main/native/include/wpi/EventLoopRunner.h
deleted file mode 100644
index 5d35d40..0000000
--- a/wpiutil/src/main/native/include/wpi/EventLoopRunner.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_EVENTLOOPRUNNER_H_
-#define WPIUTIL_WPI_EVENTLOOPRUNNER_H_
-
-#include <functional>
-#include <memory>
-
-#include "wpi/SafeThread.h"
-#include "wpi/uv/Loop.h"
-
-namespace wpi {
-
-/**
- * Executes an event loop on a separate thread.
- */
-class EventLoopRunner {
- public:
-  using LoopFunc = std::function<void(uv::Loop&)>;
-
-  EventLoopRunner();
-  virtual ~EventLoopRunner();
-
-  /**
-   * Stop the loop.  Once the loop is stopped it cannot be restarted.
-   * This function does not return until the loop has exited.
-   */
-  void Stop();
-
-  /**
-   * Run a function asynchronously (once) on the loop.
-   * This is safe to call from any thread, but is NOT safe to call from the
-   * provided function (it will deadlock).
-   * @param func function to execute on the loop
-   */
-  void ExecAsync(LoopFunc func);
-
-  /**
-   * Run a function synchronously (once) on the loop.
-   * This is safe to call from any thread, but is NOT safe to call from the
-   * provided function (it will deadlock).
-   * This does not return until the function finishes executing.
-   * @param func function to execute on the loop
-   */
-  void ExecSync(LoopFunc func);
-
-  /**
-   * Get the loop.  If the loop thread is not running, returns nullptr.
-   * @return The loop
-   */
-  std::shared_ptr<uv::Loop> GetLoop();
-
- private:
-  class Thread;
-  SafeThreadOwner<Thread> m_owner;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_EVENTLOOPRUNNER_H_
diff --git a/wpiutil/src/main/native/include/wpi/EventVector.h b/wpiutil/src/main/native/include/wpi/EventVector.h
new file mode 100644
index 0000000..fc54df7
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/EventVector.h
@@ -0,0 +1,51 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include "wpi/SmallVector.h"
+#include "wpi/Synchronization.h"
+#include "wpi/mutex.h"
+
+namespace wpi {
+struct EventVector {
+  wpi::mutex mutex;
+  wpi::SmallVector<WPI_EventHandle, 4> events;
+
+  /**
+   * Adds an event to the event vector.
+   *
+   * @param handle the event to add
+   */
+  void Add(WPI_EventHandle handle) {
+    std::scoped_lock lock{mutex};
+    events.emplace_back(handle);
+  }
+
+  /**
+   * Removes an event from the event vector.
+   *
+   * @param handle The event to remove
+   */
+  void Remove(WPI_EventHandle handle) {
+    std::scoped_lock lock{mutex};
+    auto it = std::find_if(
+        events.begin(), events.end(),
+        [=](const WPI_EventHandle fromHandle) { return fromHandle == handle; });
+    if (it != events.end()) {
+      events.erase(it);
+    }
+  }
+
+  /**
+   * Wakes up all events in the event vector.
+   */
+  void Wakeup() {
+    std::scoped_lock lock{mutex};
+    for (auto&& handle : events) {
+      wpi::SetEvent(handle);
+    }
+  }
+};
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/FunctionExtras.h b/wpiutil/src/main/native/include/wpi/FunctionExtras.h
deleted file mode 100644
index 57bc8dc..0000000
--- a/wpiutil/src/main/native/include/wpi/FunctionExtras.h
+++ /dev/null
@@ -1,308 +0,0 @@
-//===- FunctionExtras.h - Function type erasure utilities -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// This file provides a collection of function (or more generally, callable)
-/// type erasure utilities supplementing those provided by the standard library
-/// in `<function>`.
-///
-/// It provides `unique_function`, which works like `std::function` but supports
-/// move-only callable objects.
-///
-/// Future plans:
-/// - Add a `function` that provides const, volatile, and ref-qualified support,
-///   which doesn't work with `std::function`.
-/// - Provide support for specifying multiple signatures to type erase callable
-///   objects with an overload set, such as those produced by generic lambdas.
-/// - Expand to include a copyable utility that directly replaces std::function
-///   but brings the above improvements.
-///
-/// Note that LLVM's utilities are greatly simplified by not supporting
-/// allocators.
-///
-/// If the standard library ever begins to provide comparable facilities we can
-/// consider switching to those.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_FUNCTION_EXTRAS_H
-#define WPIUTIL_WPI_FUNCTION_EXTRAS_H
-
-#include "wpi/Compiler.h"
-#include "wpi/PointerIntPair.h"
-#include "wpi/PointerUnion.h"
-#include <memory>
-#include <type_traits>
-
-namespace wpi {
-
-template <typename FunctionT> class unique_function;
-
-// GCC warns on OutOfLineStorage
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
-template <typename ReturnT, typename... ParamTs>
-class unique_function<ReturnT(ParamTs...)> {
-  static constexpr size_t InlineStorageSize = sizeof(void *) * 4;
-
-  // MSVC has a bug and ICEs if we give it a particular dependent value
-  // expression as part of the `std::conditional` below. To work around this,
-  // we build that into a template struct's constexpr bool.
-  template <typename T> struct IsSizeLessThanThresholdT {
-    static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));
-  };
-
-  // Provide a type function to map parameters that won't observe extra copies
-  // or moves and which are small enough to likely pass in register to values
-  // and all other types to l-value reference types. We use this to compute the
-  // types used in our erased call utility to minimize copies and moves unless
-  // doing so would force things unnecessarily into memory.
-  //
-  // The heuristic used is related to common ABI register passing conventions.
-  // It doesn't have to be exact though, and in one way it is more strict
-  // because we want to still be able to observe either moves *or* copies.
-  template <typename T>
-  using AdjustedParamT = typename std::conditional<
-      !std::is_reference<T>::value &&
-          std::is_trivially_copy_constructible<T>::value &&
-          std::is_trivially_move_constructible<T>::value &&
-          IsSizeLessThanThresholdT<T>::value,
-      T, T &>::type;
-
-  // The type of the erased function pointer we use as a callback to dispatch to
-  // the stored callable when it is trivial to move and destroy.
-  using CallPtrT = ReturnT (*)(void *CallableAddr,
-                               AdjustedParamT<ParamTs>... Params);
-  using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);
-  using DestroyPtrT = void (*)(void *CallableAddr);
-
-  /// A struct to hold a single trivial callback with sufficient alignment for
-  /// our bitpacking.
-  struct alignas(8) TrivialCallback {
-    CallPtrT CallPtr;
-  };
-
-  /// A struct we use to aggregate three callbacks when we need full set of
-  /// operations.
-  struct alignas(8) NonTrivialCallbacks {
-    CallPtrT CallPtr;
-    MovePtrT MovePtr;
-    DestroyPtrT DestroyPtr;
-  };
-
-  // Create a pointer union between either a pointer to a static trivial call
-  // pointer in a struct or a pointer to a static struct of the call, move, and
-  // destroy pointers.
-  using CallbackPointerUnionT =
-      PointerUnion<TrivialCallback *, NonTrivialCallbacks *>;
-
-  // The main storage buffer. This will either have a pointer to out-of-line
-  // storage or an inline buffer storing the callable.
-  union StorageUnionT {
-    // For out-of-line storage we keep a pointer to the underlying storage and
-    // the size. This is enough to deallocate the memory.
-    struct OutOfLineStorageT {
-      void *StoragePtr;
-      size_t Size;
-      size_t Alignment;
-    } OutOfLineStorage;
-    static_assert(
-        sizeof(OutOfLineStorageT) <= InlineStorageSize,
-        "Should always use all of the out-of-line storage for inline storage!");
-
-    // For in-line storage, we just provide an aligned character buffer. We
-    // provide four pointers worth of storage here.
-    typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
-        InlineStorage;
-  } StorageUnion;
-
-  // A compressed pointer to either our dispatching callback or our table of
-  // dispatching callbacks and the flag for whether the callable itself is
-  // stored inline or not.
-  PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;
-
-  bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }
-
-  bool isTrivialCallback() const {
-    return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
-  }
-
-  CallPtrT getTrivialCallback() const {
-    return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
-  }
-
-  NonTrivialCallbacks *getNonTrivialCallbacks() const {
-    return CallbackAndInlineFlag.getPointer()
-        .template get<NonTrivialCallbacks *>();
-  }
-
-  void *getInlineStorage() { return &StorageUnion.InlineStorage; }
-
-  void *getOutOfLineStorage() {
-    return StorageUnion.OutOfLineStorage.StoragePtr;
-  }
-  size_t getOutOfLineStorageSize() const {
-    return StorageUnion.OutOfLineStorage.Size;
-  }
-  size_t getOutOfLineStorageAlignment() const {
-    return StorageUnion.OutOfLineStorage.Alignment;
-  }
-
-  void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
-    StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
-  }
-
-  template <typename CallableT>
-  static ReturnT CallImpl(void *CallableAddr, AdjustedParamT<ParamTs>... Params) {
-    return (*reinterpret_cast<CallableT *>(CallableAddr))(
-        std::forward<ParamTs>(Params)...);
-  }
-
-  template <typename CallableT>
-  static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {
-    new (LHSCallableAddr)
-        CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
-  }
-
-  template <typename CallableT>
-  static void DestroyImpl(void *CallableAddr) noexcept {
-    reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();
-  }
-
-public:
-  unique_function() = default;
-  unique_function(std::nullptr_t /*null_callable*/) {}
-
-  ~unique_function() {
-    if (!CallbackAndInlineFlag.getPointer())
-      return;
-
-    // Cache this value so we don't re-check it after type-erased operations.
-    bool IsInlineStorage = isInlineStorage();
-
-    if (!isTrivialCallback())
-      getNonTrivialCallbacks()->DestroyPtr(
-          IsInlineStorage ? getInlineStorage() : getOutOfLineStorage());
-
-    if (!IsInlineStorage)
-      deallocate_buffer(getOutOfLineStorage(), getOutOfLineStorageSize(),
-                        getOutOfLineStorageAlignment());
-  }
-
-  unique_function(unique_function &&RHS) noexcept {
-    // Copy the callback and inline flag.
-    CallbackAndInlineFlag = RHS.CallbackAndInlineFlag;
-
-    // If the RHS is empty, just copying the above is sufficient.
-    if (!RHS)
-      return;
-
-    if (!isInlineStorage()) {
-      // The out-of-line case is easiest to move.
-      StorageUnion.OutOfLineStorage = RHS.StorageUnion.OutOfLineStorage;
-    } else if (isTrivialCallback()) {
-      // Move is trivial, just memcpy the bytes across.
-      memcpy(getInlineStorage(), RHS.getInlineStorage(), InlineStorageSize);
-    } else {
-      // Non-trivial move, so dispatch to a type-erased implementation.
-      getNonTrivialCallbacks()->MovePtr(getInlineStorage(),
-                                        RHS.getInlineStorage());
-    }
-
-    // Clear the old callback and inline flag to get back to as-if-null.
-    RHS.CallbackAndInlineFlag = {};
-
-#ifndef NDEBUG
-    // In debug builds, we also scribble across the rest of the storage.
-    memset(RHS.getInlineStorage(), 0xAD, InlineStorageSize);
-#endif
-  }
-
-  unique_function &operator=(unique_function &&RHS) noexcept {
-    if (this == &RHS)
-      return *this;
-
-    // Because we don't try to provide any exception safety guarantees we can
-    // implement move assignment very simply by first destroying the current
-    // object and then move-constructing over top of it.
-    this->~unique_function();
-    new (this) unique_function(std::move(RHS));
-    return *this;
-  }
-
-  template <typename CallableT>
-  unique_function(CallableT Callable,
-                  std::enable_if_t<
-                    std::is_invocable_r_v<
-                      ReturnT, CallableT, ParamTs...>>* = nullptr) {
-    bool IsInlineStorage = true;
-    void *CallableAddr = getInlineStorage();
-    if (sizeof(CallableT) > InlineStorageSize ||
-        alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
-      IsInlineStorage = false;
-      // Allocate out-of-line storage. FIXME: Use an explicit alignment
-      // parameter in C++17 mode.
-      auto Size = sizeof(CallableT);
-      auto Alignment = alignof(CallableT);
-      CallableAddr = allocate_buffer(Size, Alignment);
-      setOutOfLineStorage(CallableAddr, Size, Alignment);
-    }
-
-    // Now move into the storage.
-    new (CallableAddr) CallableT(std::move(Callable));
-
-    // See if we can create a trivial callback. We need the callable to be
-    // trivially moved and trivially destroyed so that we don't have to store
-    // type erased callbacks for those operations.
-    //
-    // FIXME: We should use constexpr if here and below to avoid instantiating
-    // the non-trivial static objects when unnecessary. While the linker should
-    // remove them, it is still wasteful.
-    if (std::is_trivially_move_constructible<CallableT>::value &&
-        std::is_trivially_destructible<CallableT>::value) {
-      // We need to create a nicely aligned object. We use a static variable
-      // for this because it is a trivial struct.
-      static TrivialCallback Callback = { &CallImpl<CallableT> };
-
-      CallbackAndInlineFlag = {&Callback, IsInlineStorage};
-      return;
-    }
-
-    // Otherwise, we need to point at an object that contains all the different
-    // type erased behaviors needed. Create a static instance of the struct type
-    // here and then use a pointer to that.
-    static NonTrivialCallbacks Callbacks = {
-        &CallImpl<CallableT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
-
-    CallbackAndInlineFlag = {&Callbacks, IsInlineStorage};
-  }
-
-  ReturnT operator()(ParamTs... Params) {
-    void *CallableAddr =
-        isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();
-
-    return (isTrivialCallback()
-                ? getTrivialCallback()
-                : getNonTrivialCallbacks()->CallPtr)(CallableAddr, Params...);
-  }
-
-  explicit operator bool() const {
-    return (bool)CallbackAndInlineFlag.getPointer();
-  }
-};
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-} // end namespace wpi
-
-#endif // WPIUTIL_WPI_FUNCTION_H
diff --git a/wpiutil/src/main/native/include/wpi/HttpParser.h b/wpiutil/src/main/native/include/wpi/HttpParser.h
deleted file mode 100644
index 72e5dad..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpParser.h
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPPARSER_H_
-#define WPIUTIL_WPI_HTTPPARSER_H_
-
-#include <stdint.h>
-
-#include <string_view>
-
-#include "wpi/Signal.h"
-#include "wpi/SmallString.h"
-#include "wpi/http_parser.h"
-
-namespace wpi {
-
-/**
- * HTTP protocol parser.  Performs incremental parsing with callbacks for each
- * part of the HTTP protocol.  As this is incremental, it's suitable for use
- * with event based frameworks that provide arbitrary chunks of data.
- */
-class HttpParser {
- public:
-  enum Type {
-    kRequest = HTTP_REQUEST,
-    kResponse = HTTP_RESPONSE,
-    kBoth = HTTP_BOTH
-  };
-
-  /**
-   * Returns the library version. Bits 16-23 contain the major version number,
-   * bits 8-15 the minor version number and bits 0-7 the patch level.
-   */
-  static uint32_t GetParserVersion();
-
-  /**
-   * Constructor.
-   * @param type Type of parser (request or response or both)
-   */
-  explicit HttpParser(Type type);
-
-  /**
-   * Reset the parser to initial state.
-   * This allows reusing the same parser object from request to request.
-   * @param type Type of parser (request or response or both)
-   */
-  void Reset(Type type);
-
-  /**
-   * Set the maximum accepted length for URLs, field names, and field values.
-   * The default is 1024.
-   * @param len maximum length
-   */
-  void SetMaxLength(size_t len) { m_maxLength = len; }
-
-  /**
-   * Executes the parser.  An empty input is treated as EOF.
-   * @param in input data
-   * @return Trailing input data after the parse.
-   */
-  std::string_view Execute(std::string_view in) {
-    in.remove_prefix(
-        http_parser_execute(&m_parser, &m_settings, in.data(), in.size()));
-    return in;
-  }
-
-  /**
-   * Get HTTP major version.
-   */
-  unsigned int GetMajor() const { return m_parser.http_major; }
-
-  /**
-   * Get HTTP minor version.
-   */
-  unsigned int GetMinor() const { return m_parser.http_minor; }
-
-  /**
-   * Get HTTP status code.  Valid only on responses.  Valid in and after
-   * the OnStatus() callback has been called.
-   */
-  unsigned int GetStatusCode() const { return m_parser.status_code; }
-
-  /**
-   * Get HTTP method.  Valid only on requests.
-   */
-  http_method GetMethod() const {
-    return static_cast<http_method>(m_parser.method);
-  }
-
-  /**
-   * Determine if an error occurred.
-   * @return False if no error.
-   */
-  bool HasError() const { return m_parser.http_errno != HPE_OK; }
-
-  /**
-   * Get error number.
-   */
-  http_errno GetError() const {
-    return static_cast<http_errno>(m_parser.http_errno);
-  }
-
-  /**
-   * Abort the parse.  Call this from a callback handler to indicate an error.
-   * This will result in GetError() returning one of the callback-related
-   * errors (e.g. HPE_CB_message_begin).
-   */
-  void Abort() { m_aborted = true; }
-
-  /**
-   * Determine if an upgrade header was present and the parser has exited
-   * because of that.  Should be checked when Execute() returns in addition to
-   * checking GetError().
-   * @return True if upgrade header, false otherwise.
-   */
-  bool IsUpgrade() const { return m_parser.upgrade; }
-
-  /**
-   * If this returns false in the headersComplete or messageComplete
-   * callback, then this should be the last message on the connection.
-   * If you are the server, respond with the "Connection: close" header.
-   * If you are the client, close the connection.
-   */
-  bool ShouldKeepAlive() const { return http_should_keep_alive(&m_parser); }
-
-  /**
-   * Pause the parser.
-   * @param paused True to pause, false to unpause.
-   */
-  void Pause(bool paused) { http_parser_pause(&m_parser, paused); }
-
-  /**
-   * Checks if this is the final chunk of the body.
-   */
-  bool IsBodyFinal() const { return http_body_is_final(&m_parser); }
-
-  /**
-   * Get URL.  Valid in and after the url callback has been called.
-   */
-  std::string_view GetUrl() const { return m_urlBuf.str(); }
-
-  /**
-   * Message begin callback.
-   */
-  sig::Signal<> messageBegin;
-
-  /**
-   * URL callback.
-   *
-   * The parameter to the callback is the complete URL string.
-   */
-  sig::Signal<std::string_view> url;
-
-  /**
-   * Status callback.
-   *
-   * The parameter to the callback is the complete status string.
-   * GetStatusCode() can be used to get the numeric status code.
-   */
-  sig::Signal<std::string_view> status;
-
-  /**
-   * Header field callback.
-   *
-   * The parameters to the callback are the field name and field value.
-   */
-  sig::Signal<std::string_view, std::string_view> header;
-
-  /**
-   * Headers complete callback.
-   *
-   * The parameter to the callback is whether the connection should be kept
-   * alive.  If this is false, then this should be the last message on the
-   * connection.  If you are the server, respond with the "Connection: close"
-   * header.  If you are the client, close the connection.
-   */
-  sig::Signal<bool> headersComplete;
-
-  /**
-   * Body data callback.
-   *
-   * The parameters to the callback is the data chunk and whether this is the
-   * final chunk of data in the message.  Note this callback will be called
-   * multiple times arbitrarily (e.g. it's possible that it may be called with
-   * just a few characters at a time).
-   */
-  sig::Signal<std::string_view, bool> body;
-
-  /**
-   * Headers complete callback.
-   *
-   * The parameter to the callback is whether the connection should be kept
-   * alive.  If this is false, then this should be the last message on the
-   * connection.  If you are the server, respond with the "Connection: close"
-   * header.  If you are the client, close the connection.
-   */
-  sig::Signal<bool> messageComplete;
-
-  /**
-   * Chunk header callback.
-   *
-   * The parameter to the callback is the chunk size.
-   */
-  sig::Signal<uint64_t> chunkHeader;
-
-  /**
-   * Chunk complete callback.
-   */
-  sig::Signal<> chunkComplete;
-
- private:
-  http_parser m_parser;
-  http_parser_settings m_settings;
-
-  size_t m_maxLength = 1024;
-  enum { kStart, kUrl, kStatus, kField, kValue } m_state = kStart;
-  SmallString<128> m_urlBuf;
-  SmallString<32> m_fieldBuf;
-  SmallString<128> m_valueBuf;
-
-  bool m_aborted = false;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_HTTPPARSER_H_
diff --git a/wpiutil/src/main/native/include/wpi/HttpServerConnection.h b/wpiutil/src/main/native/include/wpi/HttpServerConnection.h
deleted file mode 100644
index a4d4cf8..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpServerConnection.h
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPSERVERCONNECTION_H_
-#define WPIUTIL_WPI_HTTPSERVERCONNECTION_H_
-
-#include <memory>
-#include <string_view>
-
-#include "wpi/HttpParser.h"
-#include "wpi/span.h"
-#include "wpi/uv/Stream.h"
-
-namespace wpi {
-
-class raw_ostream;
-
-class HttpServerConnection {
- public:
-  explicit HttpServerConnection(std::shared_ptr<uv::Stream> stream);
-  virtual ~HttpServerConnection() = default;
-
- protected:
-  /**
-   * Process an incoming HTTP request.  This is called after the incoming
-   * message completes (e.g. from the HttpParser::messageComplete callback).
-   *
-   * The implementation should read request details from m_request and call the
-   * appropriate Send() functions to send a response back to the client.
-   */
-  virtual void ProcessRequest() = 0;
-
-  /**
-   * Build common response headers.
-   *
-   * Called by SendHeader() to send headers common to every response.
-   * Each line must be terminated with "\r\n".
-   *
-   * The default implementation sends the following:
-   * "Server: WebServer/1.0\r\n"
-   * "Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, "
-   * "post-check=0, max-age=0\r\n"
-   * "Pragma: no-cache\r\n"
-   * "Expires: Mon, 3 Jan 2000 12:34:56 GMT\r\n"
-   *
-   * These parameters should ensure the browser does not cache the response.
-   * A browser should connect for each file and not serve files from its cache.
-   *
-   * @param os response stream
-   */
-  virtual void BuildCommonHeaders(raw_ostream& os);
-
-  /**
-   * Build HTTP response header, along with other header information like
-   * mimetype.  Calls BuildCommonHeaders().
-   *
-   * @param os response stream
-   * @param code HTTP response code (e.g. 200)
-   * @param codeText HTTP response code text (e.g. "OK")
-   * @param contentType MIME content type (e.g. "text/plain")
-   * @param contentLength Length of content.  If 0 is provided, m_keepAlive will
-   *                      be set to false.
-   * @param extra Extra HTTP headers to send, including final "\r\n"
-   */
-  virtual void BuildHeader(raw_ostream& os, int code, std::string_view codeText,
-                           std::string_view contentType, uint64_t contentLength,
-                           std::string_view extra = {});
-
-  /**
-   * Send data to client.
-   *
-   * This is a convenience wrapper around m_stream.Write() to provide
-   * auto-close functionality.
-   *
-   * @param bufs Buffers to write.  Deallocate() will be called on each
-   *             buffer after the write completes.  If different behavior
-   *             is desired, call m_stream.Write() directly instead.
-   * @param closeAfter close the connection after the write completes
-   */
-  void SendData(span<const uv::Buffer> bufs, bool closeAfter = false);
-
-  /**
-   * Send HTTP response, along with other header information like mimetype.
-   * Calls BuildHeader().
-   *
-   * @param code HTTP response code (e.g. 200)
-   * @param codeText HTTP response code text (e.g. "OK")
-   * @param contentType MIME content type (e.g. "text/plain")
-   * @param content Response message content
-   * @param extraHeader Extra HTTP headers to send, including final "\r\n"
-   */
-  virtual void SendResponse(int code, std::string_view codeText,
-                            std::string_view contentType,
-                            std::string_view content,
-                            std::string_view extraHeader = {});
-
-  /**
-   * Send HTTP response from static data, along with other header information
-   * like mimetype.  Calls BuildHeader().  Supports gzip pre-compressed data
-   * (it will decompress if the client does not accept gzip encoded data).
-   * Unlike SendResponse(), content is not copied and its contents must remain
-   * valid for an unspecified lifetime.
-   *
-   * @param code HTTP response code (e.g. 200)
-   * @param codeText HTTP response code text (e.g. "OK")
-   * @param contentType MIME content type (e.g. "text/plain")
-   * @param content Response message content
-   * @param gzipped True if content is gzip compressed
-   * @param extraHeader Extra HTTP headers to send, including final "\r\n"
-   */
-  virtual void SendStaticResponse(int code, std::string_view codeText,
-                                  std::string_view contentType,
-                                  std::string_view content, bool gzipped,
-                                  std::string_view extraHeader = {});
-
-  /**
-   * Send error header and message.
-   * This provides standard code responses for 400, 401, 403, 404, 500, and 503.
-   * Other codes will be reported as 501.  For arbitrary code handling, use
-   * SendResponse() instead.
-   *
-   * @param code HTTP error code (e.g. 404)
-   * @param message Additional message text
-   */
-  virtual void SendError(int code, std::string_view message = {});
-
-  /** The HTTP request. */
-  HttpParser m_request{HttpParser::kRequest};
-
-  /** Whether the connection should be kept alive. */
-  bool m_keepAlive = false;
-
-  /** If gzip is an acceptable encoding for responses. */
-  bool m_acceptGzip = false;
-
-  /** The underlying stream for the connection. */
-  uv::Stream& m_stream;
-
-  /** The header reader connection. */
-  sig::ScopedConnection m_dataConn;
-
-  /** The end stream connection. */
-  sig::ScopedConnection m_endConn;
-
-  /** The message complete connection. */
-  sig::Connection m_messageCompleteConn;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_HTTPSERVERCONNECTION_H_
diff --git a/wpiutil/src/main/native/include/wpi/HttpUtil.h b/wpiutil/src/main/native/include/wpi/HttpUtil.h
deleted file mode 100644
index b10d127..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpUtil.h
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPUTIL_H_
-#define WPIUTIL_WPI_HTTPUTIL_H_
-
-#include <initializer_list>
-#include <memory>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include "wpi/NetworkStream.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringMap.h"
-#include "wpi/raw_istream.h"
-#include "wpi/raw_socket_istream.h"
-#include "wpi/raw_socket_ostream.h"
-#include "wpi/span.h"
-
-namespace wpi {
-
-// Unescape a %xx-encoded URI.
-// @param buf Buffer for output
-// @param error Set to true if an error occurred
-// @return Escaped string
-std::string_view UnescapeURI(std::string_view str, SmallVectorImpl<char>& buf,
-                             bool* error);
-
-// Escape a string with %xx-encoding.
-// @param buf Buffer for output
-// @param spacePlus If true, encodes spaces to '+' rather than "%20"
-// @return Escaped string
-std::string_view EscapeURI(std::string_view str, SmallVectorImpl<char>& buf,
-                           bool spacePlus = true);
-
-// Parse a set of HTTP headers.  Saves just the Content-Type and Content-Length
-// fields.
-// @param is Input stream
-// @param contentType If not null, Content-Type contents are saved here.
-// @param contentLength If not null, Content-Length contents are saved here.
-// @return False if error occurred in input stream
-bool ParseHttpHeaders(raw_istream& is, SmallVectorImpl<char>* contentType,
-                      SmallVectorImpl<char>* contentLength);
-
-// Look for a MIME multi-part boundary.  On return, the input stream will
-// be located at the character following the boundary (usually "\r\n").
-// @param is Input stream
-// @param boundary Boundary string to scan for (not including "--" prefix)
-// @param saveBuf If not null, all scanned characters up to but not including
-//     the boundary are saved to this string
-// @return False if error occurred on input stream, true if boundary found.
-bool FindMultipartBoundary(wpi::raw_istream& is, std::string_view boundary,
-                           std::string* saveBuf);
-
-/**
- * Map for looking up elements of the query portion of a URI.  Does not
- * handle multiple elements with the same name.  This is a reference type;
- * it does not make a copy of the query string, so it is important that the
- * query string has a lifetime at least as long as this object.
- */
-class HttpQueryMap {
- public:
-  /**
-   * Constructs an empty map (with no entries).
-   */
-  HttpQueryMap() = default;
-
-  /**
-   * Constructs from an escaped query string.  Note: does not make a copy of
-   * the query string, so it must not be a temporary.
-   *
-   * @param query query string
-   */
-  explicit HttpQueryMap(std::string_view query);
-
-  /**
-   * Gets an element of the query string.  Both the name and the returned
-   * value are unescaped strings.
-   *
-   * @param name name (unescaped)
-   * @param buf result buffer for value
-   * @return Optional unescaped value.  Returns an empty optional if the
-   *         name is not present in the query map.
-   */
-  std::optional<std::string_view> Get(std::string_view name,
-                                      SmallVectorImpl<char>& buf) const;
-
- private:
-  StringMap<std::string_view> m_elems;
-};
-
-class HttpPathRef;
-
-/**
- * Class for HTTP path matching.  A root path is represented as a single
- * empty element, otherwise the path consists of each non-empty element
- * between the '/' characters:
- *  - "" -> []
- *  - "/" -> [""]
- *  - "/foo" -> ["foo"]
- *  - "/foo/bar" -> ["foo", "bar"]
- *  - "/foo//bar/" -> ["foo", "bar"]
- *
- * All path elements are unescaped.
- */
-class HttpPath {
- public:
-  /**
-   * Constructs an empty HTTP path.
-   */
-  HttpPath() = default;
-
-  /**
-   * Constructs a HTTP path from an escaped path string.  Makes a copy of the
-   * path, so it's safe to be a temporary.
-   */
-  explicit HttpPath(std::string_view path);
-
-  /**
-   * Evaluates to true if the path is not empty.
-   */
-  explicit operator bool() const { return !empty(); }
-
-  /**
-   * Returns true if the path has no elements.
-   */
-  bool empty() const { return m_pathEnds.empty(); }
-
-  /**
-   * Returns number of elements in the path.
-   */
-  size_t size() const { return m_pathEnds.size(); }
-
-  /**
-   * Returns true if the path exactly matches the provided match list.
-   *
-   * @param match match list
-   * @return True if path equals match list
-   */
-  bool equals(std::initializer_list<std::string_view> match) const {
-    return equals(0, {match.begin(), match.end()});
-  }
-  bool equals(span<const std::string_view> match) const {
-    return equals(0, match);
-  }
-  bool equals(std::string_view match) const { return equals(0, {match}); }
-
-  /**
-   * Returns true if the elements of the path starting at the "start" element
-   * match the provided match list, and there are no additional elements.
-   *
-   * @param start element to start matching at
-   * @param match match list
-   * @return True if match
-   */
-  bool equals(size_t start,
-              std::initializer_list<std::string_view> match) const {
-    return equals(start, {match.begin(), match.end()});
-  }
-  bool equals(size_t start, span<const std::string_view> match) const {
-    if (m_pathEnds.size() != (start + match.size())) {
-      return false;
-    }
-    return startswith(start, match);
-  }
-  bool equals(size_t start, std::string_view match) const {
-    return equals(start, {match});
-  }
-
-  /**
-   * Returns true if the first elements of the path match the provided match
-   * list.  The path may have additional elements.
-   *
-   * @param match match list
-   * @return True if path starts with match list
-   */
-  bool startswith(std::initializer_list<std::string_view> match) const {
-    return startswith(0, {match.begin(), match.end()});
-  }
-  bool startswith(span<const std::string_view> match) const {
-    return startswith(0, match);
-  }
-  bool startswith(std::string_view match) const {
-    return startswith(0, {match});
-  }
-
-  /**
-   * Returns true if the elements of the path starting at the "start" element
-   * match the provided match list.  The path may have additional elements.
-   *
-   * @param start element to start matching at
-   * @param match match list
-   * @return True if path starting at the start element matches the match list
-   */
-  bool startswith(size_t start,
-                  std::initializer_list<std::string_view> match) const {
-    return startswith(start, {match.begin(), match.end()});
-  }
-
-  bool startswith(size_t start, span<const std::string_view> match) const;
-
-  bool startswith(size_t start, std::string_view match) const {
-    return startswith(start, {match});
-  }
-
-  /**
-   * Gets a single element of the path.
-   */
-  std::string_view operator[](size_t n) const;
-
-  /**
-   * Returns a path reference with the first N elements of the path removed.
-   */
-  HttpPathRef drop_front(size_t n) const;
-
- private:
-  SmallString<128> m_pathBuf;
-  SmallVector<size_t, 16> m_pathEnds;
-};
-
-/**
- * Proxy reference object for a portion of a HttpPath.
- */
-class HttpPathRef {
- public:
-  HttpPathRef() = default;
-  /*implicit*/ HttpPathRef(const HttpPath& path,  // NOLINT
-                           size_t start = 0)
-      : m_path(&path), m_start(start) {}
-
-  explicit operator bool() const { return !empty(); }
-  bool empty() const { return m_path && m_path->size() == m_start; }
-  size_t size() const { return m_path ? m_path->size() - m_start : 0; }
-
-  bool equals(std::initializer_list<std::string_view> match) const {
-    return equals(0, {match.begin(), match.end()});
-  }
-  bool equals(span<const std::string_view> match) const {
-    return equals(0, match);
-  }
-  bool equals(std::string_view match) const { return equals(0, {match}); }
-
-  bool equals(size_t start,
-              std::initializer_list<std::string_view> match) const {
-    return equals(start, {match.begin(), match.end()});
-  }
-  bool equals(size_t start, span<const std::string_view> match) const {
-    return m_path ? m_path->equals(m_start + start, match) : false;
-  }
-  bool equals(size_t start, std::string_view match) const {
-    return equals(start, {match});
-  }
-
-  bool startswith(std::initializer_list<std::string_view> match) const {
-    return startswith(0, {match.begin(), match.end()});
-  }
-  bool startswith(span<const std::string_view> match) const {
-    return startswith(0, match);
-  }
-  bool startswith(std::string_view match) const {
-    return startswith(0, {match});
-  }
-
-  bool startswith(size_t start,
-                  std::initializer_list<std::string_view> match) const {
-    return startswith(start, {match.begin(), match.end()});
-  }
-  bool startswith(size_t start, span<const std::string_view> match) const {
-    return m_path ? m_path->startswith(m_start + start, match) : false;
-  }
-  bool startswith(size_t start, std::string_view match) const {
-    return startswith(start, {match});
-  }
-
-  std::string_view operator[](size_t n) const {
-    return m_path ? m_path->operator[](m_start + n) : std::string_view{};
-  }
-  HttpPathRef drop_front(size_t n) const {
-    return m_path ? m_path->drop_front(m_start + n) : HttpPathRef{};
-  }
-
- private:
-  const HttpPath* m_path = nullptr;
-  size_t m_start = 0;
-};
-
-class HttpLocation {
- public:
-  HttpLocation() = default;
-  HttpLocation(std::string_view url_, bool* error, std::string* errorMsg);
-
-  std::string url;       // retain copy
-  std::string user;      // unescaped
-  std::string password;  // unescaped
-  std::string host;
-  int port;
-  std::string path;  // escaped, not including leading '/'
-  std::vector<std::pair<std::string, std::string>> params;  // unescaped
-  std::string fragment;
-};
-
-class HttpRequest {
- public:
-  HttpRequest() = default;
-
-  explicit HttpRequest(const HttpLocation& loc)
-      : host{loc.host}, port{loc.port} {
-    SetPath(loc.path, loc.params);
-    SetAuth(loc);
-  }
-
-  template <typename T>
-  HttpRequest(const HttpLocation& loc, const T& extraParams);
-
-  HttpRequest(const HttpLocation& loc, std::string_view path_)
-      : host{loc.host}, port{loc.port}, path{path_} {
-    SetAuth(loc);
-  }
-
-  template <typename T>
-  HttpRequest(const HttpLocation& loc, std::string_view path_, const T& params)
-      : host{loc.host}, port{loc.port} {
-    SetPath(path_, params);
-    SetAuth(loc);
-  }
-
-  SmallString<128> host;
-  int port;
-  std::string auth;
-  SmallString<128> path;
-
- private:
-  void SetAuth(const HttpLocation& loc);
-  template <typename T>
-  void SetPath(std::string_view path_, const T& params);
-
-  template <typename T>
-  static std::string_view GetFirst(const T& elem) {
-    return elem.first;
-  }
-  template <typename T>
-  static std::string_view GetFirst(const StringMapEntry<T>& elem) {
-    return elem.getKey();
-  }
-  template <typename T>
-  static std::string_view GetSecond(const T& elem) {
-    return elem.second;
-  }
-};
-
-class HttpConnection {
- public:
-  HttpConnection(std::unique_ptr<wpi::NetworkStream> stream_, int timeout)
-      : stream{std::move(stream_)}, is{*stream, timeout}, os{*stream, true} {}
-
-  bool Handshake(const HttpRequest& request, std::string* warnMsg);
-
-  std::unique_ptr<wpi::NetworkStream> stream;
-  wpi::raw_socket_istream is;
-  wpi::raw_socket_ostream os;
-
-  // Valid after Handshake() is successful
-  SmallString<64> contentType;
-  SmallString<64> contentLength;
-
-  explicit operator bool() const { return stream && !is.has_error(); }
-};
-
-class HttpMultipartScanner {
- public:
-  explicit HttpMultipartScanner(std::string_view boundary,
-                                bool saveSkipped = false) {
-    Reset(saveSkipped);
-    SetBoundary(boundary);
-  }
-
-  // Change the boundary.  This is only safe to do when IsDone() is true (or
-  // immediately after construction).
-  void SetBoundary(std::string_view boundary);
-
-  // Reset the scanner.  This allows reuse of internal buffers.
-  void Reset(bool saveSkipped = false);
-
-  // Execute the scanner.  Will automatically call Reset() on entry if IsDone()
-  // is true.
-  // @param in input data
-  // @return the input not consumed; empty if all input consumed
-  std::string_view Execute(std::string_view in);
-
-  // Returns true when the boundary has been found.
-  bool IsDone() const { return m_state == kDone; }
-
-  // Get the skipped data.  Will be empty if saveSkipped was false.
-  std::string_view GetSkipped() const {
-    return m_saveSkipped ? std::string_view{m_buf} : std::string_view{};
-  }
-
- private:
-  SmallString<64> m_boundaryWith, m_boundaryWithout;
-
-  // Internal state
-  enum State { kBoundary, kPadding, kDone };
-  State m_state;
-  size_t m_posWith, m_posWithout;
-  enum Dashes { kUnknown, kWith, kWithout };
-  Dashes m_dashes;
-
-  // Buffer
-  bool m_saveSkipped;
-  std::string m_buf;
-};
-
-}  // namespace wpi
-
-#include "HttpUtil.inc"
-
-#endif  // WPIUTIL_WPI_HTTPUTIL_H_
diff --git a/wpiutil/src/main/native/include/wpi/HttpUtil.inc b/wpiutil/src/main/native/include/wpi/HttpUtil.inc
deleted file mode 100644
index 726cdfb..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpUtil.inc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPUTIL_INC_
-#define WPIUTIL_WPI_HTTPUTIL_INC_
-
-#include <utility>
-
-#include "wpi/HttpUtil.h"
-
-namespace wpi {
-
-inline HttpPathRef HttpPath::drop_front(size_t n) const {
-  return HttpPathRef(*this, n);
-}
-
-template <typename T>
-HttpRequest::HttpRequest(const HttpLocation& loc, const T& extraParams)
-    : host{loc.host}, port{loc.port} {
-  StringMap<std::string_view> params;
-  for (const auto& p : loc.params) {
-    params.insert(std::make_pair(GetFirst(p), GetSecond(p)));
-  }
-  for (const auto& p : extraParams) {
-    params.insert(std::make_pair(GetFirst(p), GetSecond(p)));
-  }
-  SetPath(loc.path, params);
-  SetAuth(loc);
-}
-
-template <typename T>
-void HttpRequest::SetPath(std::string_view path_, const T& params) {
-  // Build location including query string
-  raw_svector_ostream pathOs{path};
-  pathOs << path_;
-  bool first = true;
-  for (const auto& param : params) {
-    if (first) {
-      pathOs << '?';
-      first = false;
-    } else {
-      pathOs << '&';
-    }
-    SmallString<64> escapeBuf;
-    pathOs << EscapeURI(GetFirst(param), escapeBuf, false);
-    if (!GetSecond(param).empty()) {
-      pathOs << '=' << EscapeURI(GetSecond(param), escapeBuf, false);
-    }
-  }
-}
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_HTTPUTIL_INC_
diff --git a/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.h b/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.h
deleted file mode 100644
index d89b61f..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_H_
-#define WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_H_
-
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/HttpServerConnection.h"
-#include "wpi/SmallVector.h"
-#include "wpi/WebSocket.h"
-#include "wpi/WebSocketServer.h"
-#include "wpi/span.h"
-#include "wpi/uv/Stream.h"
-
-namespace wpi {
-
-/**
- * A server-side HTTP connection that also accepts WebSocket upgrades.
- *
- * @tparam Derived derived class for std::enable_shared_from_this.
- */
-template <typename Derived>
-class HttpWebSocketServerConnection
-    : public HttpServerConnection,
-      public std::enable_shared_from_this<Derived> {
- public:
-  /**
-   * Constructor.
-   *
-   * @param stream network stream
-   * @param protocols Acceptable subprotocols
-   */
-  HttpWebSocketServerConnection(std::shared_ptr<uv::Stream> stream,
-                                span<const std::string_view> protocols);
-
-  /**
-   * Constructor.
-   *
-   * @param stream network stream
-   * @param protocols Acceptable subprotocols
-   */
-  HttpWebSocketServerConnection(
-      std::shared_ptr<uv::Stream> stream,
-      std::initializer_list<std::string_view> protocols)
-      : HttpWebSocketServerConnection(stream,
-                                      {protocols.begin(), protocols.end()}) {}
-
- protected:
-  /**
-   * Check that an incoming WebSocket upgrade is okay.  This is called prior
-   * to accepting the upgrade (so prior to ProcessWsUpgrade()).
-   *
-   * The implementation should check other headers and return true if the
-   * WebSocket connection should be accepted.
-   *
-   * @param protocol negotiated subprotocol
-   */
-  virtual bool IsValidWsUpgrade(std::string_view protocol) { return true; }
-
-  /**
-   * Process an incoming WebSocket upgrade.  This is called after the header
-   * reader has been disconnected and the websocket has been accepted.
-   *
-   * The implementation should set up appropriate callbacks on the websocket
-   * object to continue communication.
-   *
-   * @note When a WebSocket upgrade occurs, the stream user data is replaced
-   *       with the websocket, and the websocket user data points to "this".
-   *       Replace the websocket user data with caution!
-   */
-  virtual void ProcessWsUpgrade() = 0;
-
-  /**
-   * WebSocket connection; not valid until ProcessWsUpgrade is called.
-   */
-  WebSocket* m_websocket = nullptr;
-
- private:
-  WebSocketServerHelper m_helper;
-  SmallVector<std::string, 2> m_protocols;
-};
-
-}  // namespace wpi
-
-#include "HttpWebSocketServerConnection.inc"
-
-#endif  // WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_H_
diff --git a/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.inc b/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.inc
deleted file mode 100644
index 68b9f2d..0000000
--- a/wpiutil/src/main/native/include/wpi/HttpWebSocketServerConnection.inc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_INC_
-#define WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_INC_
-
-#include <memory>
-
-#include "wpi/HttpWebSocketServerConnection.h"
-
-namespace wpi {
-
-template <typename Derived>
-HttpWebSocketServerConnection<Derived>::HttpWebSocketServerConnection(
-    std::shared_ptr<uv::Stream> stream, span<const std::string_view> protocols)
-    : HttpServerConnection{stream},
-      m_helper{m_request},
-      m_protocols{protocols.begin(), protocols.end()} {
-  // Handle upgrade event
-  m_helper.upgrade.connect([this] {
-    // Negotiate sub-protocol
-    SmallVector<std::string_view, 2> protocols{m_protocols.begin(),
-                                               m_protocols.end()};
-    std::string_view protocol = m_helper.MatchProtocol(protocols).second;
-
-    // Check that the upgrade is valid
-    if (!IsValidWsUpgrade(protocol)) {
-      return;
-    }
-
-    // Disconnect HttpServerConnection header reader
-    m_dataConn.disconnect();
-    m_messageCompleteConn.disconnect();
-
-    // Accepting the stream may destroy this (as it replaces the stream user
-    // data), so grab a shared pointer first.
-    auto self = this->shared_from_this();
-
-    // Accept the upgrade
-    auto ws = m_helper.Accept(m_stream, protocol);
-
-    // Set this as the websocket user data to keep it around
-    ws->SetData(self);
-
-    // Store in member
-    m_websocket = ws.get();
-
-    // Call derived class function
-    ProcessWsUpgrade();
-  });
-}
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_HTTPWEBSOCKETSERVERCONNECTION_INC_
diff --git a/wpiutil/src/main/native/include/wpi/Logger.h b/wpiutil/src/main/native/include/wpi/Logger.h
index 807e472..883336f 100644
--- a/wpiutil/src/main/native/include/wpi/Logger.h
+++ b/wpiutil/src/main/native/include/wpi/Logger.h
@@ -45,12 +45,11 @@
   void LogV(unsigned int level, const char* file, unsigned int line,
             fmt::string_view format, fmt::format_args args);
 
-  template <typename S, typename... Args>
+  template <typename... Args>
   void Log(unsigned int level, const char* file, unsigned int line,
-           const S& format, Args&&... args) {
+           fmt::string_view format, Args&&... args) {
     if (m_func && level >= m_min_level) {
-      LogV(level, file, line, format,
-           fmt::make_args_checked<Args...>(format, args...));
+      LogV(level, file, line, format, fmt::make_format_args(args...));
     }
   }
 
@@ -61,15 +60,25 @@
   unsigned int m_min_level = 20;
 };
 
-#define WPI_LOG(logger_inst, level, format, ...) \
-  logger_inst.Log(level, __FILE__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+// C++20 relaxed the number of arguments to variadics, but Apple Clang's
+// warnings haven't caught up yet: https://stackoverflow.com/a/67996331
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+#endif
+
+#define WPI_LOG(logger_inst, level, format, ...)                         \
+  if ((logger_inst).HasLogger() && level >= (logger_inst).min_level()) { \
+    (logger_inst)                                                        \
+        .Log(level, __FILE__, __LINE__,                                  \
+             FMT_STRING(format) __VA_OPT__(, ) __VA_ARGS__);             \
+  }
 
 #define WPI_ERROR(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_ERROR, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_ERROR, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_WARNING(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_WARNING, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_WARNING, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_INFO(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_INFO, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_INFO, format __VA_OPT__(, ) __VA_ARGS__)
 
 #ifdef NDEBUG
 #define WPI_DEBUG(inst, format, ...) \
@@ -89,15 +98,15 @@
   } while (0)
 #else
 #define WPI_DEBUG(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_DEBUG1(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG1, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG1, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_DEBUG2(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG2, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG2, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_DEBUG3(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG3, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG3, format __VA_OPT__(, ) __VA_ARGS__)
 #define WPI_DEBUG4(inst, format, ...) \
-  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG4, format, __VA_ARGS__)
+  WPI_LOG(inst, ::wpi::WPI_LOG_DEBUG4, format __VA_OPT__(, ) __VA_ARGS__)
 #endif
 
 }  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/ManagedStatic.h b/wpiutil/src/main/native/include/wpi/ManagedStatic.h
deleted file mode 100644
index 28c11fa..0000000
--- a/wpiutil/src/main/native/include/wpi/ManagedStatic.h
+++ /dev/null
@@ -1,104 +0,0 @@
-//===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the ManagedStatic class and the wpi_shutdown() function.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_MANAGEDSTATIC_H
-#define WPIUTIL_WPI_MANAGEDSTATIC_H
-
-#include <atomic>
-#include <cstddef>
-
-namespace wpi {
-
-/// object_creator - Helper method for ManagedStatic.
-template <class C> struct object_creator {
-  static void *call() { return new C(); }
-};
-
-/// object_deleter - Helper method for ManagedStatic.
-///
-template <typename T> struct object_deleter {
-  static void call(void *Ptr) { delete (T *)Ptr; }
-};
-template <typename T, size_t N> struct object_deleter<T[N]> {
-  static void call(void *Ptr) { delete[](T *)Ptr; }
-};
-
-/// ManagedStaticBase - Common base class for ManagedStatic instances.
-class ManagedStaticBase {
-protected:
-  // This should only be used as a static variable, which guarantees that this
-  // will be zero initialized.
-  mutable std::atomic<void *> Ptr;
-  mutable void (*DeleterFn)(void*);
-  mutable const ManagedStaticBase *Next;
-
-  void RegisterManagedStatic(void *(*creator)(), void (*deleter)(void*)) const;
-  void RegisterManagedStatic(void *created, void (*deleter)(void*)) const;
-
-public:
-  /// isConstructed - Return true if this object has not been created yet.
-  bool isConstructed() const { return Ptr != nullptr; }
-
-  void destroy() const;
-};
-
-/// ManagedStatic - This transparently changes the behavior of global statics to
-/// be lazily constructed on demand (good for reducing startup times of dynamic
-/// libraries that link in LLVM components) and for making destruction be
-/// explicit through the wpi_shutdown() function call.
-///
-template <class C, class Creator = object_creator<C>,
-          class Deleter = object_deleter<C>>
-class ManagedStatic : public ManagedStaticBase {
-public:
-  ManagedStatic() = default;
-
-  ManagedStatic(C* created, void(*deleter)(void*)) {
-    RegisterManagedStatic(created, deleter);
-  }
-
-  // Accessors.
-  C &operator*() {
-    void *Tmp = Ptr.load(std::memory_order_acquire);
-    if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
-
-    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
-  }
-
-  C *operator->() { return &**this; }
-
-  const C &operator*() const {
-    void *Tmp = Ptr.load(std::memory_order_acquire);
-    if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
-
-    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
-  }
-
-  const C *operator->() const { return &**this; }
-};
-
-/// wpi_shutdown - Deallocate and destroy all ManagedStatic variables.
-void wpi_shutdown();
-
-/// wpi_shutdown_obj - This is a simple helper class that calls
-/// wpi_shutdown() when it is destroyed.
-struct wpi_shutdown_obj {
-  wpi_shutdown_obj() = default;
-  ~wpi_shutdown_obj() { wpi_shutdown(); }
-};
-
-} // end namespace wpi
-
-#endif // WPIUTIL_WPI_MANAGEDSTATIC_H
diff --git a/wpiutil/src/main/native/include/wpi/MappedFileRegion.h b/wpiutil/src/main/native/include/wpi/MappedFileRegion.h
new file mode 100644
index 0000000..05e487e
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/MappedFileRegion.h
@@ -0,0 +1,92 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <system_error>
+
+// Duplicated from fs.h to avoid a dependency
+namespace fs {
+#if defined(_WIN32)
+// A Win32 HANDLE is a typedef of void*
+using file_t = void*;
+#else
+using file_t = int;
+#endif
+}  // namespace fs
+
+namespace wpi {
+
+class MappedFileRegion {
+ public:
+  enum MapMode {
+    kReadOnly,   ///< May only access map via const_data as read only.
+    kReadWrite,  ///< May access map via data and modify it. Written to path.
+    kPriv        ///< May modify via data, but changes are lost on destruction.
+  };
+
+  MappedFileRegion() = default;
+  MappedFileRegion(fs::file_t f, uint64_t length, uint64_t offset,
+                   MapMode mapMode, std::error_code& ec);
+  ~MappedFileRegion() { Unmap(); }
+
+  MappedFileRegion(const MappedFileRegion&) = delete;
+  MappedFileRegion& operator=(const MappedFileRegion&) = delete;
+
+  MappedFileRegion(MappedFileRegion&& rhs)
+      : m_size(rhs.m_size), m_mapping(rhs.m_mapping) {
+    rhs.m_mapping = nullptr;
+#ifdef _WIN32
+    m_fileHandle = rhs.m_fileHandle;
+    rhs.m_fileHandle = nullptr;
+#endif
+  }
+
+  MappedFileRegion& operator=(MappedFileRegion&& rhs) {
+    if (m_mapping) {
+      Unmap();
+    }
+    m_size = rhs.m_size;
+    m_mapping = rhs.m_mapping;
+    rhs.m_mapping = nullptr;
+#ifdef _WIN32
+    m_fileHandle = rhs.m_fileHandle;
+    rhs.m_fileHandle = nullptr;
+#endif
+    return *this;
+  }
+
+  explicit operator bool() const {
+    return m_mapping != nullptr;
+  }
+
+  void Flush();
+  void Unmap();
+
+  uint64_t size() const {
+    return m_size;
+  }
+  uint8_t* data() const {
+    return static_cast<uint8_t*>(m_mapping);
+  }
+  const uint8_t* const_data() const {
+    return static_cast<const uint8_t*>(m_mapping);
+  }
+
+  /**
+   * Returns required alignment.
+   */
+  static size_t GetAlignment();
+
+ private:
+  uint64_t m_size = 0;
+  void* m_mapping = nullptr;
+#ifdef _WIN32
+  fs::file_t m_fileHandle = nullptr;
+#endif
+};
+
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/MemAlloc.h b/wpiutil/src/main/native/include/wpi/MemAlloc.h
deleted file mode 100644
index addccb5..0000000
--- a/wpiutil/src/main/native/include/wpi/MemAlloc.h
+++ /dev/null
@@ -1,61 +0,0 @@
-//===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-/// \file
-///
-/// This file defines counterparts of C library allocation functions defined in
-/// the namespace 'std'. The new allocation functions crash on allocation
-/// failure instead of returning null pointer.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_MEMALLOC_H
-#define WPIUTIL_WPI_MEMALLOC_H
-
-#include "wpi/Compiler.h"
-#include "wpi/ErrorHandling.h"
-#include <cstdlib>
-
-namespace wpi {
-
-#ifdef _WIN32
-#pragma warning(push)
-// Warning on NONNULL, report is not known to abort
-#pragma warning(disable : 6387)
-#pragma warning(disable : 28196)
-#pragma warning(disable : 28183)
-#endif
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
-  void *Result = std::malloc(Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed");
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
-                                                        size_t Sz) {
-  void *Result = std::calloc(Count, Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed");
-  return Result;
-}
-
-LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
-  void *Result = std::realloc(Ptr, Sz);
-  if (Result == nullptr)
-    report_bad_alloc_error("Allocation failed");
-  return Result;
-}
-
-#ifdef _WIN32
-#pragma warning(pop)
-#endif
-
-}
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/MessagePack.h b/wpiutil/src/main/native/include/wpi/MessagePack.h
new file mode 100644
index 0000000..e1f54e5
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/MessagePack.h
@@ -0,0 +1,39 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <span>
+#include <string>
+#include <string_view>
+
+#include "wpi/mpack.h"
+
+namespace mpack {
+
+inline void mpack_write_str(mpack_writer_t* writer, std::string_view str) {
+  mpack_write_str(writer, str.data(), str.size());
+}
+
+inline void mpack_write_bytes(mpack_writer_t* writer,
+                              std::span<const uint8_t> data) {
+  mpack_write_bytes(writer, reinterpret_cast<const char*>(data.data()),
+                    data.size());
+}
+
+inline void mpack_reader_init_data(mpack_reader_t* reader,
+                                   std::span<const uint8_t> data) {
+  mpack_reader_init_data(reader, reinterpret_cast<const char*>(data.data()),
+                         data.size());
+}
+
+mpack_error_t mpack_expect_str(mpack_reader_t* reader, std::string* out,
+                               uint32_t maxLen = 1024);
+
+mpack_error_t mpack_read_str(mpack_reader_t* reader, mpack_tag_t* tag,
+                             std::string* out, uint32_t maxLen = 1024);
+
+}  // namespace mpack
diff --git a/wpiutil/src/main/native/include/wpi/MimeTypes.h b/wpiutil/src/main/native/include/wpi/MimeTypes.h
deleted file mode 100644
index ce36ea2..0000000
--- a/wpiutil/src/main/native/include/wpi/MimeTypes.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_MIMETYPES_H_
-#define WPIUTIL_WPI_MIMETYPES_H_
-
-#include <string_view>
-
-namespace wpi {
-
-std::string_view MimeTypeFromPath(std::string_view path);
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_MIMETYPES_H_
diff --git a/wpiutil/src/main/native/include/wpi/MulticastServiceAnnouncer.h b/wpiutil/src/main/native/include/wpi/MulticastServiceAnnouncer.h
deleted file mode 100644
index 5d2048d..0000000
--- a/wpiutil/src/main/native/include/wpi/MulticastServiceAnnouncer.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-
-#include "wpi/span.h"
-namespace wpi {
-class MulticastServiceAnnouncer {
- public:
-  MulticastServiceAnnouncer(
-      std::string_view serviceName, std::string_view serviceType, int port,
-      wpi::span<const std::pair<std::string, std::string>> txt);
-  MulticastServiceAnnouncer(
-      std::string_view serviceName, std::string_view serviceType, int port,
-      wpi::span<const std::pair<std::string_view, std::string_view>> txt);
-  ~MulticastServiceAnnouncer() noexcept;
-  void Start();
-  void Stop();
-  bool HasImplementation() const;
-  struct Impl;
-
- private:
-  std::unique_ptr<Impl> pImpl;
-};
-}  // namespace wpi
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef unsigned int WPI_MulticastServiceAnnouncerHandle;  // NOLINT
-
-WPI_MulticastServiceAnnouncerHandle WPI_CreateMulticastServiceAnnouncer(
-    const char* serviceName, const char* serviceType, int32_t port,
-    int32_t txtCount, const char** keys, const char** values);
-
-void WPI_FreeMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle);
-
-void WPI_StartMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle);
-
-void WPI_StopMulticastServiceAnnouncer(
-    WPI_MulticastServiceAnnouncerHandle handle);
-
-int32_t WPI_GetMulticastServiceAnnouncerHasImplementation(
-    WPI_MulticastServiceAnnouncerHandle handle);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/MulticastServiceResolver.h b/wpiutil/src/main/native/include/wpi/MulticastServiceResolver.h
deleted file mode 100644
index 0b63c2f..0000000
--- a/wpiutil/src/main/native/include/wpi/MulticastServiceResolver.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include "wpi/Synchronization.h"
-
-#ifdef __cplusplus
-#include <functional>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include "wpi/mutex.h"
-#include "wpi/span.h"
-namespace wpi {
-class MulticastServiceResolver {
- public:
-  explicit MulticastServiceResolver(std::string_view serviceType);
-  ~MulticastServiceResolver() noexcept;
-  struct ServiceData {
-    unsigned int ipv4Address;
-    int port;
-    std::string serviceName;
-    std::string hostName;
-    std::vector<std::pair<std::string, std::string>> txt;
-  };
-  void Start();
-  void Stop();
-  WPI_EventHandle GetEventHandle() const { return event.GetHandle(); }
-  std::vector<ServiceData> GetData() {
-    std::scoped_lock lock{mutex};
-    event.Reset();
-    if (queue.empty()) {
-      return {};
-    }
-    std::vector<ServiceData> ret;
-    queue.swap(ret);
-    return ret;
-  }
-  bool HasImplementation() const;
-  struct Impl;
-
- private:
-  void PushData(ServiceData&& data) {
-    std::scoped_lock lock{mutex};
-    queue.emplace_back(std::forward<ServiceData>(data));
-    event.Set();
-  }
-  wpi::Event event{true};
-  std::vector<ServiceData> queue;
-  wpi::mutex mutex;
-  std::unique_ptr<Impl> pImpl;
-};
-}  // namespace wpi
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef unsigned int WPI_MulticastServiceResolverHandle;  // NOLINT
-
-WPI_MulticastServiceResolverHandle WPI_CreateMulticastServiceResolver(
-    const char* serviceType);
-
-void WPI_FreeMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle);
-
-void WPI_StartMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle);
-
-void WPI_StopMulticastServiceResolver(
-    WPI_MulticastServiceResolverHandle handle);
-
-int32_t WPI_GetMulticastServiceResolverHasImplementation(
-    WPI_MulticastServiceResolverHandle handle);
-
-WPI_EventHandle WPI_GetMulticastServiceResolverEventHandle(
-    WPI_MulticastServiceResolverHandle handle);
-
-typedef struct WPI_ServiceData {  // NOLINT
-  uint32_t ipv4Address;
-  int32_t port;
-  const char* serviceName;
-  const char* hostName;
-  int32_t txtCount;
-  const char** txtKeys;
-  const char** txtValues;
-} WPI_ServiceData;
-
-WPI_ServiceData* WPI_GetMulticastServiceResolverData(
-    WPI_MulticastServiceResolverHandle handle, int32_t* dataCount);
-
-void WPI_FreeServiceData(WPI_ServiceData* serviceData, int32_t length);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/NetworkAcceptor.h b/wpiutil/src/main/native/include/wpi/NetworkAcceptor.h
deleted file mode 100644
index 9982360..0000000
--- a/wpiutil/src/main/native/include/wpi/NetworkAcceptor.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_NETWORKACCEPTOR_H_
-#define WPIUTIL_WPI_NETWORKACCEPTOR_H_
-
-#include <memory>
-
-#include "wpi/NetworkStream.h"
-
-namespace wpi {
-
-class NetworkAcceptor {
- public:
-  NetworkAcceptor() = default;
-  virtual ~NetworkAcceptor() = default;
-
-  virtual int start() = 0;
-  virtual void shutdown() = 0;
-  virtual std::unique_ptr<NetworkStream> accept() = 0;
-
-  NetworkAcceptor(const NetworkAcceptor&) = delete;
-  NetworkAcceptor& operator=(const NetworkAcceptor&) = delete;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_NETWORKACCEPTOR_H_
diff --git a/wpiutil/src/main/native/include/wpi/NetworkStream.h b/wpiutil/src/main/native/include/wpi/NetworkStream.h
deleted file mode 100644
index b842ecd..0000000
--- a/wpiutil/src/main/native/include/wpi/NetworkStream.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_NETWORKSTREAM_H_
-#define WPIUTIL_WPI_NETWORKSTREAM_H_
-
-#include <cstddef>
-#include <string_view>
-
-namespace wpi {
-
-class NetworkStream {
- public:
-  NetworkStream() = default;
-  virtual ~NetworkStream() = default;
-
-  enum Error {
-    kConnectionClosed = 0,
-    kConnectionReset = -1,
-    kConnectionTimedOut = -2,
-    kWouldBlock = -3
-  };
-
-  virtual size_t send(const char* buffer, size_t len, Error* err) = 0;
-  virtual size_t receive(char* buffer, size_t len, Error* err,
-                         int timeout = 0) = 0;
-  virtual void close() = 0;
-
-  virtual std::string_view getPeerIP() const = 0;
-  virtual int getPeerPort() const = 0;
-  virtual void setNoDelay() = 0;
-
-  // returns false on failure
-  virtual bool setBlocking(bool enabled) = 0;
-  virtual int getNativeHandle() const = 0;
-
-  NetworkStream(const NetworkStream&) = delete;
-  NetworkStream& operator=(const NetworkStream&) = delete;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_NETWORKSTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/ParallelTcpConnector.h b/wpiutil/src/main/native/include/wpi/ParallelTcpConnector.h
deleted file mode 100644
index 47c29d0..0000000
--- a/wpiutil/src/main/native/include/wpi/ParallelTcpConnector.h
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <stdint.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "wpi/span.h"
-#include "wpi/uv/Timer.h"
-
-namespace wpi {
-
-class Logger;
-
-namespace uv {
-class GetAddrInfoReq;
-class Loop;
-class Tcp;
-class Timer;
-}  // namespace uv
-
-/**
- * Parallel TCP connector.  Attempts parallel resolution and connection to
- * multiple servers with automatic retry if none connect.
- *
- * Each successful TCP connection results in a call to the connected callback.
- * For correct operation, the consuming code (either the connected callback or
- * e.g. task it starts) must call Succeeded() to indicate if the connection has
- * succeeded prior to the reconnect rate timeout.  A successful connection
- * results in the connector terminating all other connection attempts.
- *
- * After the reconnect rate times out, all remaining active connection attempts
- * are canceled and new ones started.
- */
-class ParallelTcpConnector
-    : public std::enable_shared_from_this<ParallelTcpConnector> {
-  struct private_init {};
-
- public:
-  /**
-   * Create.
-   *
-   * @param loop loop
-   * @param reconnectRate how long to wait after starting connection attempts
-   *                      to cancel and attempt connecting again
-   * @param logger logger
-   * @param connected callback function when a connection succeeds; may be
-   *                  called multiple times if it does not call Succeeded()
-   *                  before returning
-   * @return Parallel connector
-   */
-  static std::shared_ptr<ParallelTcpConnector> Create(
-      wpi::uv::Loop& loop, wpi::uv::Timer::Time reconnectRate,
-      wpi::Logger& logger, std::function<void(wpi::uv::Tcp& tcp)> connected) {
-    return std::make_shared<ParallelTcpConnector>(
-        loop, reconnectRate, logger, std::move(connected), private_init{});
-  }
-
-  ParallelTcpConnector(wpi::uv::Loop& loop, wpi::uv::Timer::Time reconnectRate,
-                       wpi::Logger& logger,
-                       std::function<void(wpi::uv::Tcp& tcp)> connected,
-                       const private_init&);
-  ~ParallelTcpConnector();
-
-  ParallelTcpConnector(const ParallelTcpConnector&) = delete;
-  ParallelTcpConnector& operator=(const ParallelTcpConnector&) = delete;
-
-  /**
-   * Closes resources, canceling all pending action attempts.
-   */
-  void Close();
-
-  /**
-   * Changes the servers/ports to connect to.  Starts connection attempts if not
-   * already connected.
-   *
-   * @param servers array of server/port pairs
-   */
-  void SetServers(
-      wpi::span<const std::pair<std::string, unsigned int>> servers);
-
-  /**
-   * Tells the parallel connector that the current connection has terminated and
-   * it is necessary to start reconnection attempts.
-   */
-  void Disconnected();
-
-  /**
-   * Tells the parallel connector that a particular connection has succeeded and
-   * it should stop trying to connect.
-   *
-   * @param tcp connection passed to connected callback
-   */
-  void Succeeded(wpi::uv::Tcp& tcp);
-
- private:
-  bool IsConnected() const { return m_isConnected || m_servers.empty(); }
-  void Connect();
-  void CancelAll(wpi::uv::Tcp* except = nullptr);
-
-  wpi::uv::Loop& m_loop;
-  wpi::Logger& m_logger;
-  wpi::uv::Timer::Time m_reconnectRate;
-  std::function<void(wpi::uv::Tcp& tcp)> m_connected;
-  std::shared_ptr<wpi::uv::Timer> m_reconnectTimer;
-  std::vector<std::pair<std::string, unsigned int>> m_servers;
-  std::vector<std::weak_ptr<wpi::uv::GetAddrInfoReq>> m_resolvers;
-  std::vector<std::weak_ptr<wpi::uv::Tcp>> m_attempts;
-  bool m_isConnected{false};
-};
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/PointerUnion.h b/wpiutil/src/main/native/include/wpi/PointerUnion.h
deleted file mode 100644
index 8d6e580..0000000
--- a/wpiutil/src/main/native/include/wpi/PointerUnion.h
+++ /dev/null
@@ -1,491 +0,0 @@
-//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the PointerUnion class, which is a discriminated union of
-// pointer types.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_POINTERUNION_H
-#define WPIUTIL_WPI_POINTERUNION_H
-
-#include "wpi/DenseMapInfo.h"
-#include "wpi/PointerIntPair.h"
-#include "wpi/PointerLikeTypeTraits.h"
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-
-namespace wpi {
-
-template <typename T> struct PointerUnionTypeSelectorReturn {
-  using Return = T;
-};
-
-/// Get a type based on whether two types are the same or not.
-///
-/// For:
-///
-/// \code
-///   using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
-/// \endcode
-///
-/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
-template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
-struct PointerUnionTypeSelector {
-  using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
-};
-
-template <typename T, typename RET_EQ, typename RET_NE>
-struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
-  using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
-};
-
-template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
-struct PointerUnionTypeSelectorReturn<
-    PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
-  using Return =
-      typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
-};
-
-/// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
-/// for the two template arguments.
-template <typename PT1, typename PT2> class PointerUnionUIntTraits {
-public:
-  static inline void *getAsVoidPointer(void *P) { return P; }
-  static inline void *getFromVoidPointer(void *P) { return P; }
-
-  enum {
-    PT1BitsAv = (int)(PointerLikeTypeTraits<PT1>::NumLowBitsAvailable),
-    PT2BitsAv = (int)(PointerLikeTypeTraits<PT2>::NumLowBitsAvailable),
-    NumLowBitsAvailable = PT1BitsAv < PT2BitsAv ? PT1BitsAv : PT2BitsAv
-  };
-};
-
-/// A discriminated union of two pointer types, with the discriminator in the
-/// low bit of the pointer.
-///
-/// This implementation is extremely efficient in space due to leveraging the
-/// low bits of the pointer, while exposing a natural and type-safe API.
-///
-/// Common use patterns would be something like this:
-///    PointerUnion<int*, float*> P;
-///    P = (int*)0;
-///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
-///    X = P.get<int*>();     // ok.
-///    Y = P.get<float*>();   // runtime assertion failure.
-///    Z = P.get<double*>();  // compile time failure.
-///    P = (float*)0;
-///    Y = P.get<float*>();   // ok.
-///    X = P.get<int*>();     // runtime assertion failure.
-template <typename PT1, typename PT2> class PointerUnion {
-public:
-  using ValTy =
-      PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>;
-
-private:
-  ValTy Val;
-
-  struct IsPT1 {
-    static const int Num = 0;
-  };
-  struct IsPT2 {
-    static const int Num = 1;
-  };
-  template <typename T> struct UNION_DOESNT_CONTAIN_TYPE {};
-
-public:
-  PointerUnion() = default;
-  PointerUnion(PT1 V)
-      : Val(const_cast<void *>(
-            PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) {}
-  PointerUnion(PT2 V)
-      : Val(const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)),
-            1) {}
-
-  /// Test if the pointer held in the union is null, regardless of
-  /// which type it is.
-  bool isNull() const {
-    // Convert from the void* to one of the pointer types, to make sure that
-    // we recursively strip off low bits if we have a nested PointerUnion.
-    return !PointerLikeTypeTraits<PT1>::getFromVoidPointer(Val.getPointer());
-  }
-
-  explicit operator bool() const { return !isNull(); }
-
-  /// Test if the Union currently holds the type matching T.
-  template <typename T> int is() const {
-    using Ty = typename ::wpi::PointerUnionTypeSelector<
-        PT1, T, IsPT1,
-        ::wpi::PointerUnionTypeSelector<PT2, T, IsPT2,
-                                        UNION_DOESNT_CONTAIN_TYPE<T>>>::Return;
-    int TyNo = Ty::Num;
-    return static_cast<int>(Val.getInt()) == TyNo;
-  }
-
-  /// Returns the value of the specified pointer type.
-  ///
-  /// If the specified pointer type is incorrect, assert.
-  template <typename T> T get() const {
-    assert(is<T>() && "Invalid accessor called");
-    return PointerLikeTypeTraits<T>::getFromVoidPointer(Val.getPointer());
-  }
-
-  /// Returns the current pointer if it is of the specified pointer type,
-  /// otherwises returns null.
-  template <typename T> T dyn_cast() const {
-    if (is<T>())
-      return get<T>();
-    return T();
-  }
-
-  /// If the union is set to the first pointer type get an address pointing to
-  /// it.
-  PT1 const *getAddrOfPtr1() const {
-    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
-  }
-
-  /// If the union is set to the first pointer type get an address pointing to
-  /// it.
-  PT1 *getAddrOfPtr1() {
-    assert(is<PT1>() && "Val is not the first pointer");
-    assert(
-        get<PT1>() == Val.getPointer() &&
-        "Can't get the address because PointerLikeTypeTraits changes the ptr");
-    return const_cast<PT1 *>(
-        reinterpret_cast<const PT1 *>(Val.getAddrOfPointer()));
-  }
-
-  /// Assignment from nullptr which just clears the union.
-  const PointerUnion &operator=(std::nullptr_t) {
-    Val.initWithPointer(nullptr);
-    return *this;
-  }
-
-  /// Assignment operators - Allow assigning into this union from either
-  /// pointer type, setting the discriminator to remember what it came from.
-  const PointerUnion &operator=(const PT1 &RHS) {
-    Val.initWithPointer(
-        const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(RHS)));
-    return *this;
-  }
-  const PointerUnion &operator=(const PT2 &RHS) {
-    Val.setPointerAndInt(
-        const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(RHS)),
-        1);
-    return *this;
-  }
-
-  void *getOpaqueValue() const { return Val.getOpaqueValue(); }
-  static inline PointerUnion getFromOpaqueValue(void *VP) {
-    PointerUnion V;
-    V.Val = ValTy::getFromOpaqueValue(VP);
-    return V;
-  }
-};
-
-template <typename PT1, typename PT2>
-bool operator==(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {
-  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
-}
-
-template <typename PT1, typename PT2>
-bool operator!=(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {
-  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
-}
-
-template <typename PT1, typename PT2>
-bool operator<(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) {
-  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
-}
-
-// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
-// # low bits available = min(PT1bits,PT2bits)-1.
-template <typename PT1, typename PT2>
-struct PointerLikeTypeTraits<PointerUnion<PT1, PT2>> {
-  static inline void *getAsVoidPointer(const PointerUnion<PT1, PT2> &P) {
-    return P.getOpaqueValue();
-  }
-
-  static inline PointerUnion<PT1, PT2> getFromVoidPointer(void *P) {
-    return PointerUnion<PT1, PT2>::getFromOpaqueValue(P);
-  }
-
-  // The number of bits available are the min of the two pointer types.
-  enum {
-    NumLowBitsAvailable = PointerLikeTypeTraits<
-        typename PointerUnion<PT1, PT2>::ValTy>::NumLowBitsAvailable
-  };
-};
-
-/// A pointer union of three pointer types. See documentation for PointerUnion
-/// for usage.
-template <typename PT1, typename PT2, typename PT3> class PointerUnion3 {
-public:
-  using InnerUnion = PointerUnion<PT1, PT2>;
-  using ValTy = PointerUnion<InnerUnion, PT3>;
-
-private:
-  ValTy Val;
-
-  struct IsInnerUnion {
-    ValTy Val;
-
-    IsInnerUnion(ValTy val) : Val(val) {}
-
-    template <typename T> int is() const {
-      return Val.template is<InnerUnion>() &&
-             Val.template get<InnerUnion>().template is<T>();
-    }
-
-    template <typename T> T get() const {
-      return Val.template get<InnerUnion>().template get<T>();
-    }
-  };
-
-  struct IsPT3 {
-    ValTy Val;
-
-    IsPT3(ValTy val) : Val(val) {}
-
-    template <typename T> int is() const { return Val.template is<T>(); }
-    template <typename T> T get() const { return Val.template get<T>(); }
-  };
-
-public:
-  PointerUnion3() = default;
-  PointerUnion3(PT1 V) { Val = InnerUnion(V); }
-  PointerUnion3(PT2 V) { Val = InnerUnion(V); }
-  PointerUnion3(PT3 V) { Val = V; }
-
-  /// Test if the pointer held in the union is null, regardless of
-  /// which type it is.
-  bool isNull() const { return Val.isNull(); }
-  explicit operator bool() const { return !isNull(); }
-
-  /// Test if the Union currently holds the type matching T.
-  template <typename T> int is() const {
-    // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
-    using Ty = typename ::wpi::PointerUnionTypeSelector<
-        PT1, T, IsInnerUnion,
-        ::wpi::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
-    return Ty(Val).template is<T>();
-  }
-
-  /// Returns the value of the specified pointer type.
-  ///
-  /// If the specified pointer type is incorrect, assert.
-  template <typename T> T get() const {
-    assert(is<T>() && "Invalid accessor called");
-    // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
-    using Ty = typename ::wpi::PointerUnionTypeSelector<
-        PT1, T, IsInnerUnion,
-        ::wpi::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
-    return Ty(Val).template get<T>();
-  }
-
-  /// Returns the current pointer if it is of the specified pointer type,
-  /// otherwises returns null.
-  template <typename T> T dyn_cast() const {
-    if (is<T>())
-      return get<T>();
-    return T();
-  }
-
-  /// Assignment from nullptr which just clears the union.
-  const PointerUnion3 &operator=(std::nullptr_t) {
-    Val = nullptr;
-    return *this;
-  }
-
-  /// Assignment operators - Allow assigning into this union from either
-  /// pointer type, setting the discriminator to remember what it came from.
-  const PointerUnion3 &operator=(const PT1 &RHS) {
-    Val = InnerUnion(RHS);
-    return *this;
-  }
-  const PointerUnion3 &operator=(const PT2 &RHS) {
-    Val = InnerUnion(RHS);
-    return *this;
-  }
-  const PointerUnion3 &operator=(const PT3 &RHS) {
-    Val = RHS;
-    return *this;
-  }
-
-  void *getOpaqueValue() const { return Val.getOpaqueValue(); }
-  static inline PointerUnion3 getFromOpaqueValue(void *VP) {
-    PointerUnion3 V;
-    V.Val = ValTy::getFromOpaqueValue(VP);
-    return V;
-  }
-};
-
-// Teach SmallPtrSet that PointerUnion3 is "basically a pointer", that has
-// # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
-template <typename PT1, typename PT2, typename PT3>
-struct PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3>> {
-  static inline void *getAsVoidPointer(const PointerUnion3<PT1, PT2, PT3> &P) {
-    return P.getOpaqueValue();
-  }
-
-  static inline PointerUnion3<PT1, PT2, PT3> getFromVoidPointer(void *P) {
-    return PointerUnion3<PT1, PT2, PT3>::getFromOpaqueValue(P);
-  }
-
-  // The number of bits available are the min of the two pointer types.
-  enum {
-    NumLowBitsAvailable = PointerLikeTypeTraits<
-        typename PointerUnion3<PT1, PT2, PT3>::ValTy>::NumLowBitsAvailable
-  };
-};
-
-template <typename PT1, typename PT2, typename PT3>
-bool operator<(PointerUnion3<PT1, PT2, PT3> lhs,
-               PointerUnion3<PT1, PT2, PT3> rhs) {
-  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
-}
-
-/// A pointer union of four pointer types. See documentation for PointerUnion
-/// for usage.
-template <typename PT1, typename PT2, typename PT3, typename PT4>
-class PointerUnion4 {
-public:
-  using InnerUnion1 = PointerUnion<PT1, PT2>;
-  using InnerUnion2 = PointerUnion<PT3, PT4>;
-  using ValTy = PointerUnion<InnerUnion1, InnerUnion2>;
-
-private:
-  ValTy Val;
-
-public:
-  PointerUnion4() = default;
-  PointerUnion4(PT1 V) { Val = InnerUnion1(V); }
-  PointerUnion4(PT2 V) { Val = InnerUnion1(V); }
-  PointerUnion4(PT3 V) { Val = InnerUnion2(V); }
-  PointerUnion4(PT4 V) { Val = InnerUnion2(V); }
-
-  /// Test if the pointer held in the union is null, regardless of
-  /// which type it is.
-  bool isNull() const { return Val.isNull(); }
-  explicit operator bool() const { return !isNull(); }
-
-  /// Test if the Union currently holds the type matching T.
-  template <typename T> int is() const {
-    // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
-    using Ty = typename ::wpi::PointerUnionTypeSelector<
-        PT1, T, InnerUnion1,
-        ::wpi::PointerUnionTypeSelector<PT2, T, InnerUnion1,
-                                        InnerUnion2>>::Return;
-    return Val.template is<Ty>() && Val.template get<Ty>().template is<T>();
-  }
-
-  /// Returns the value of the specified pointer type.
-  ///
-  /// If the specified pointer type is incorrect, assert.
-  template <typename T> T get() const {
-    assert(is<T>() && "Invalid accessor called");
-    // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
-    using Ty = typename ::wpi::PointerUnionTypeSelector<
-        PT1, T, InnerUnion1,
-        ::wpi::PointerUnionTypeSelector<PT2, T, InnerUnion1,
-                                        InnerUnion2>>::Return;
-    return Val.template get<Ty>().template get<T>();
-  }
-
-  /// Returns the current pointer if it is of the specified pointer type,
-  /// otherwises returns null.
-  template <typename T> T dyn_cast() const {
-    if (is<T>())
-      return get<T>();
-    return T();
-  }
-
-  /// Assignment from nullptr which just clears the union.
-  const PointerUnion4 &operator=(std::nullptr_t) {
-    Val = nullptr;
-    return *this;
-  }
-
-  /// Assignment operators - Allow assigning into this union from either
-  /// pointer type, setting the discriminator to remember what it came from.
-  const PointerUnion4 &operator=(const PT1 &RHS) {
-    Val = InnerUnion1(RHS);
-    return *this;
-  }
-  const PointerUnion4 &operator=(const PT2 &RHS) {
-    Val = InnerUnion1(RHS);
-    return *this;
-  }
-  const PointerUnion4 &operator=(const PT3 &RHS) {
-    Val = InnerUnion2(RHS);
-    return *this;
-  }
-  const PointerUnion4 &operator=(const PT4 &RHS) {
-    Val = InnerUnion2(RHS);
-    return *this;
-  }
-
-  void *getOpaqueValue() const { return Val.getOpaqueValue(); }
-  static inline PointerUnion4 getFromOpaqueValue(void *VP) {
-    PointerUnion4 V;
-    V.Val = ValTy::getFromOpaqueValue(VP);
-    return V;
-  }
-};
-
-// Teach SmallPtrSet that PointerUnion4 is "basically a pointer", that has
-// # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
-template <typename PT1, typename PT2, typename PT3, typename PT4>
-struct PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4>> {
-  static inline void *
-  getAsVoidPointer(const PointerUnion4<PT1, PT2, PT3, PT4> &P) {
-    return P.getOpaqueValue();
-  }
-
-  static inline PointerUnion4<PT1, PT2, PT3, PT4> getFromVoidPointer(void *P) {
-    return PointerUnion4<PT1, PT2, PT3, PT4>::getFromOpaqueValue(P);
-  }
-
-  // The number of bits available are the min of the two pointer types.
-  enum {
-    NumLowBitsAvailable = PointerLikeTypeTraits<
-        typename PointerUnion4<PT1, PT2, PT3, PT4>::ValTy>::NumLowBitsAvailable
-  };
-};
-
-// Teach DenseMap how to use PointerUnions as keys.
-template <typename T, typename U> struct DenseMapInfo<PointerUnion<T, U>> {
-  using Pair = PointerUnion<T, U>;
-  using FirstInfo = DenseMapInfo<T>;
-  using SecondInfo = DenseMapInfo<U>;
-
-  static inline Pair getEmptyKey() { return Pair(FirstInfo::getEmptyKey()); }
-
-  static inline Pair getTombstoneKey() {
-    return Pair(FirstInfo::getTombstoneKey());
-  }
-
-  static unsigned getHashValue(const Pair &PairVal) {
-    intptr_t key = (intptr_t)PairVal.getOpaqueValue();
-    return DenseMapInfo<intptr_t>::getHashValue(key);
-  }
-
-  static bool isEqual(const Pair &LHS, const Pair &RHS) {
-    return LHS.template is<T>() == RHS.template is<T>() &&
-           (LHS.template is<T>() ? FirstInfo::isEqual(LHS.template get<T>(),
-                                                      RHS.template get<T>())
-                                 : SecondInfo::isEqual(LHS.template get<U>(),
-                                                       RHS.template get<U>()));
-  }
-};
-
-} // end namespace wpi
-
-#endif // WPIUTIL_WPI_POINTERUNION_H
diff --git a/wpiutil/src/main/native/include/wpi/PortForwarder.h b/wpiutil/src/main/native/include/wpi/PortForwarder.h
deleted file mode 100644
index 9e445a0..0000000
--- a/wpiutil/src/main/native/include/wpi/PortForwarder.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_PORTFORWARDER_H_
-#define WPIUTIL_WPI_PORTFORWARDER_H_
-
-#pragma once
-
-#include <memory>
-#include <string_view>
-
-namespace wpi {
-
-/**
- * Forward ports to another host.  This is primarily useful for accessing
- * Ethernet-connected devices from a computer tethered to the RoboRIO USB port.
- */
-class PortForwarder {
- public:
-  PortForwarder(const PortForwarder&) = delete;
-  PortForwarder& operator=(const PortForwarder&) = delete;
-
-  /**
-   * Get an instance of the PortForwarder class.
-   *
-   * This is a singleton to guarantee that there is only a single instance
-   * regardless of how many times GetInstance is called.
-   */
-  static PortForwarder& GetInstance();
-
-  /**
-   * Forward a local TCP port to a remote host and port.
-   * Note that local ports less than 1024 won't work as a normal user.
-   *
-   * @param port       local port number
-   * @param remoteHost remote IP address / DNS name
-   * @param remotePort remote port number
-   */
-  void Add(unsigned int port, std::string_view remoteHost,
-           unsigned int remotePort);
-
-  /**
-   * Stop TCP forwarding on a port.
-   *
-   * @param port local port number
-   */
-  void Remove(unsigned int port);
-
- private:
-  PortForwarder();
-
-  struct Impl;
-  std::unique_ptr<Impl> m_impl;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_PORTFORWARDER_H_
diff --git a/wpiutil/src/main/native/include/wpi/SafeThread.h b/wpiutil/src/main/native/include/wpi/SafeThread.h
index bf37732..753dc6c 100644
--- a/wpiutil/src/main/native/include/wpi/SafeThread.h
+++ b/wpiutil/src/main/native/include/wpi/SafeThread.h
@@ -10,6 +10,7 @@
 #include <thread>
 #include <utility>
 
+#include "wpi/Synchronization.h"
 #include "wpi/condition_variable.h"
 #include "wpi/mutex.h"
 
@@ -18,17 +19,33 @@
 /**
  * Base class for SafeThreadOwner threads.
  */
-class SafeThread {
+class SafeThreadBase {
  public:
-  virtual ~SafeThread() = default;
+  virtual ~SafeThreadBase() = default;
   virtual void Main() = 0;
+  virtual void Stop() = 0;
 
   mutable wpi::mutex m_mutex;
   std::atomic_bool m_active{true};
-  wpi::condition_variable m_cond;
   std::thread::id m_threadId;
 };
 
+class SafeThread : public SafeThreadBase {
+ public:
+  void Stop() override;
+
+  wpi::condition_variable m_cond;
+};
+
+class SafeThreadEvent : public SafeThreadBase {
+ public:
+  SafeThreadEvent() : m_stopEvent{true} {}
+
+  void Stop() override;
+
+  Event m_stopEvent;
+};
+
 namespace detail {
 
 /**
@@ -36,12 +53,12 @@
  */
 class SafeThreadProxyBase {
  public:
-  explicit SafeThreadProxyBase(std::shared_ptr<SafeThread> thr);
+  explicit SafeThreadProxyBase(std::shared_ptr<SafeThreadBase> thr);
   explicit operator bool() const { return m_thread != nullptr; }
   std::unique_lock<wpi::mutex>& GetLock() { return m_lock; }
 
  protected:
-  std::shared_ptr<SafeThread> m_thread;
+  std::shared_ptr<SafeThreadBase> m_thread;
   std::unique_lock<wpi::mutex> m_lock;
 };
 
@@ -53,7 +70,7 @@
 template <typename T>
 class SafeThreadProxy : public SafeThreadProxyBase {
  public:
-  explicit SafeThreadProxy(std::shared_ptr<SafeThread> thr)
+  explicit SafeThreadProxy(std::shared_ptr<SafeThreadBase> thr)
       : SafeThreadProxyBase(std::move(thr)) {}
   T& operator*() const { return *static_cast<T*>(m_thread.get()); }
   T* operator->() const { return static_cast<T*>(m_thread.get()); }
@@ -89,13 +106,13 @@
   void SetJoinAtExit(bool joinAtExit) { m_joinAtExit = joinAtExit; }
 
  protected:
-  void Start(std::shared_ptr<SafeThread> thr);
-  std::shared_ptr<SafeThread> GetThreadSharedPtr() const;
+  void Start(std::shared_ptr<SafeThreadBase> thr);
+  std::shared_ptr<SafeThreadBase> GetThreadSharedPtr() const;
 
  private:
   mutable wpi::mutex m_mutex;
   std::thread m_stdThread;
-  std::weak_ptr<SafeThread> m_thread;
+  std::weak_ptr<SafeThreadBase> m_thread;
   std::atomic_bool m_joinAtExit{true};
 };
 
diff --git a/wpiutil/src/main/native/include/wpi/SmallVector.h b/wpiutil/src/main/native/include/wpi/SmallVector.h
deleted file mode 100644
index 430f85a..0000000
--- a/wpiutil/src/main/native/include/wpi/SmallVector.h
+++ /dev/null
@@ -1,949 +0,0 @@
-//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the SmallVector class.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_SMALLVECTOR_H
-#define WPIUTIL_WPI_SMALLVECTOR_H
-
-// This file uses std::memcpy() to copy std::pair<unsigned int, unsigned int>.
-// That type is POD, but the standard doesn't guarantee that. GCC doesn't treat
-// the type as POD so it throws a warning. We want to consider this a warning
-// instead of an error.
-#if __GNUC__ >= 8
-#pragma GCC diagnostic warning "-Wclass-memaccess"
-#endif
-
-#include "wpi/iterator_range.h"
-#include "wpi/AlignOf.h"
-#include "wpi/Compiler.h"
-#include "wpi/MathExtras.h"
-#include "wpi/MemAlloc.h"
-#include "wpi/type_traits.h"
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <initializer_list>
-#include <iterator>
-#include <memory>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-namespace wpi {
-
-/// This is all the non-templated stuff common to all SmallVectors.
-class SmallVectorBase {
-protected:
-  void *BeginX;
-  unsigned Size = 0, Capacity;
-
-  SmallVectorBase() = delete;
-  SmallVectorBase(void *FirstEl, size_t Capacity)
-      : BeginX(FirstEl), Capacity(static_cast<unsigned>(Capacity)) {}
-
-  /// This is an implementation of the grow() method which only works
-  /// on POD-like data types and is out of line to reduce code duplication.
-  void grow_pod(void *FirstEl, size_t MinCapacity, size_t TSize);
-
-public:
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  size_t size() const { return Size; }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  size_t capacity() const { return Capacity; }
-
-  LLVM_NODISCARD bool empty() const { return !Size; }
-
-  /// Set the array size to \p N, which the current array must have enough
-  /// capacity for.
-  ///
-  /// This does not construct or destroy any elements in the vector.
-  ///
-  /// Clients can use this in conjunction with capacity() to write past the end
-  /// of the buffer when they know that more elements are available, and only
-  /// update the size later. This avoids the cost of value initializing elements
-  /// which will only be overwritten.
-  void set_size(size_t Size) {
-    assert(Size <= capacity());
-    this->Size = static_cast<unsigned>(Size);
-  }
-};
-
-/// Figure out the offset of the first element.
-template <class T, typename = void> struct SmallVectorAlignmentAndSize {
-  AlignedCharArrayUnion<SmallVectorBase> Base;
-  AlignedCharArrayUnion<T> FirstEl;
-};
-
-/// This is the part of SmallVectorTemplateBase which does not depend on whether
-/// the type T is a POD. The extra dummy template argument is used by ArrayRef
-/// to avoid unnecessarily requiring T to be complete.
-template <typename T, typename = void>
-class SmallVectorTemplateCommon : public SmallVectorBase {
-  /// Find the address of the first element.  For this pointer math to be valid
-  /// with small-size of 0 for T with lots of alignment, it's important that
-  /// SmallVectorStorage is properly-aligned even for small-size of 0.
-  void *getFirstEl() const {
-    return const_cast<void *>(reinterpret_cast<const void *>(
-        reinterpret_cast<const char *>(this) +
-        offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)));
-  }
-  // Space after 'FirstEl' is clobbered, do not add any instance vars after it.
-
-protected:
-  SmallVectorTemplateCommon(size_t Size)
-      : SmallVectorBase(getFirstEl(), Size) {}
-
-  void grow_pod(size_t MinCapacity, size_t TSize) {
-    SmallVectorBase::grow_pod(getFirstEl(), MinCapacity, TSize);
-  }
-
-  /// Return true if this is a smallvector which has not had dynamic
-  /// memory allocated for it.
-  bool isSmall() const { return BeginX == getFirstEl(); }
-
-  /// Put this vector in a state of being small.
-  void resetToSmall() {
-    BeginX = getFirstEl();
-    Size = Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
-  }
-
-public:
-  using size_type = size_t;
-  using difference_type = ptrdiff_t;
-  using value_type = T;
-  using iterator = T *;
-  using const_iterator = const T *;
-
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-
-  using reference = T &;
-  using const_reference = const T &;
-  using pointer = T *;
-  using const_pointer = const T *;
-
-  // forward iterator creation methods.
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  iterator begin() { return (iterator)this->BeginX; }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  const_iterator begin() const { return (const_iterator)this->BeginX; }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  iterator end() { return begin() + size(); }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  const_iterator end() const { return begin() + size(); }
-
-  // reverse iterator creation methods.
-  reverse_iterator rbegin()            { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
-  reverse_iterator rend()              { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
-
-  size_type size_in_bytes() const { return size() * sizeof(T); }
-  size_type max_size() const { return size_type(-1) / sizeof(T); }
-
-  size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
-
-  /// Return a pointer to the vector's buffer, even if empty().
-  pointer data() { return pointer(begin()); }
-  /// Return a pointer to the vector's buffer, even if empty().
-  const_pointer data() const { return const_pointer(begin()); }
-
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  reference operator[](size_type idx) {
-    assert(idx < size());
-    return begin()[idx];
-  }
-  LLVM_ATTRIBUTE_ALWAYS_INLINE
-  const_reference operator[](size_type idx) const {
-    assert(idx < size());
-    return begin()[idx];
-  }
-
-  reference front() {
-    assert(!empty());
-    return begin()[0];
-  }
-  const_reference front() const {
-    assert(!empty());
-    return begin()[0];
-  }
-
-  reference back() {
-    assert(!empty());
-    return end()[-1];
-  }
-  const_reference back() const {
-    assert(!empty());
-    return end()[-1];
-  }
-};
-
-/// SmallVectorTemplateBase<isPodLike = false> - This is where we put method
-/// implementations that are designed to work with non-POD-like T's.
-template <typename T, bool = isPodLike<T>::value>
-class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
-protected:
-  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
-
-  static void destroy_range(T *S, T *E) {
-    while (S != E) {
-      --E;
-      E->~T();
-    }
-  }
-
-  /// Move the range [I, E) into the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
-    std::uninitialized_copy(std::make_move_iterator(I),
-                            std::make_move_iterator(E), Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
-  /// constructing elements as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
-    std::uninitialized_copy(I, E, Dest);
-  }
-
-  /// Grow the allocated memory (without initializing new elements), doubling
-  /// the size of the allocated memory. Guarantees space for at least one more
-  /// element, or MinSize more elements if specified.
-  void grow(size_t MinSize = 0);
-
-public:
-  void push_back(const T &Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    ::new ((void*) this->end()) T(Elt);
-    this->set_size(this->size() + 1);
-  }
-
-  void push_back(T &&Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    ::new ((void*) this->end()) T(::std::move(Elt));
-    this->set_size(this->size() + 1);
-  }
-
-  void pop_back() {
-    this->set_size(this->size() - 1);
-    this->end()->~T();
-  }
-};
-
-// Define this out-of-line to dissuade the C++ compiler from inlining it.
-template <typename T, bool isPodLike>
-void SmallVectorTemplateBase<T, isPodLike>::grow(size_t MinSize) {
-  if (MinSize > UINT32_MAX)
-    report_bad_alloc_error("SmallVector capacity overflow during allocation");
-
-  // Always grow, even from zero.
-  size_t NewCapacity = size_t(NextPowerOf2(this->capacity() + 2));
-  NewCapacity = (std::min)((std::max)(NewCapacity, MinSize), size_t(UINT32_MAX));
-  T *NewElts = static_cast<T*>(wpi::safe_malloc(NewCapacity*sizeof(T)));
-
-  // Move the elements over.
-  this->uninitialized_move(this->begin(), this->end(), NewElts);
-
-  // Destroy the original elements.
-  destroy_range(this->begin(), this->end());
-
-  // If this wasn't grown from the inline copy, deallocate the old space.
-  if (!this->isSmall())
-    free(this->begin());
-
-  this->BeginX = NewElts;
-  this->Capacity = static_cast<unsigned>(NewCapacity);
-}
-
-
-/// SmallVectorTemplateBase<isPodLike = true> - This is where we put method
-/// implementations that are designed to work with POD-like T's.
-template <typename T>
-class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
-protected:
-  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
-
-  // No need to do a destroy loop for POD's.
-  static void destroy_range(T *, T *) {}
-
-  /// Move the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
-    // Just do a copy.
-    uninitialized_copy(I, E, Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template<typename It1, typename It2>
-  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
-    // Arbitrary iterator types; just use the basic implementation.
-    std::uninitialized_copy(I, E, Dest);
-  }
-
-  /// Copy the range [I, E) onto the uninitialized memory
-  /// starting with "Dest", constructing elements into it as needed.
-  template <typename T1, typename T2>
-  static void uninitialized_copy(
-      T1 *I, T1 *E, T2 *Dest,
-      typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
-                                           T2>::value>::type * = nullptr) {
-    // Use memcpy for PODs iterated by pointers (which includes SmallVector
-    // iterators): std::uninitialized_copy optimizes to memmove, but we can
-    // use memcpy here. Note that I and E are iterators and thus might be
-    // invalid for memcpy if they are equal.
-    if (I != E)
-      memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
-  }
-
-  /// Double the size of the allocated memory, guaranteeing space for at
-  /// least one more element or MinSize if specified.
-  void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
-
-public:
-  void push_back(const T &Elt) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
-    this->set_size(this->size() + 1);
-  }
-
-  void pop_back() { this->set_size(this->size() - 1); }
-};
-
-/// This class consists of common code factored out of the SmallVector class to
-/// reduce code duplication based on the SmallVector 'N' template parameter.
-template <typename T>
-class SmallVectorImpl : public SmallVectorTemplateBase<T> {
-  using SuperClass = SmallVectorTemplateBase<T>;
-
-public:
-  using iterator = typename SuperClass::iterator;
-  using const_iterator = typename SuperClass::const_iterator;
-  using size_type = typename SuperClass::size_type;
-
-protected:
-  // Default ctor - Initialize to empty.
-  explicit SmallVectorImpl(unsigned N)
-      : SmallVectorTemplateBase<T, isPodLike<T>::value>(N) {}
-
-public:
-  SmallVectorImpl(const SmallVectorImpl &) = delete;
-
-  ~SmallVectorImpl() {
-    // Subclass has already destructed this vector's elements.
-    // If this wasn't grown from the inline copy, deallocate the old space.
-    if (!this->isSmall())
-      free(this->begin());
-  }
-
-  void clear() {
-    this->destroy_range(this->begin(), this->end());
-    this->Size = 0;
-  }
-
-  void resize(size_type N) {
-    if (N < this->size()) {
-      this->destroy_range(this->begin()+N, this->end());
-      this->set_size(N);
-    } else if (N > this->size()) {
-      if (this->capacity() < N)
-        this->grow(N);
-      for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
-        new (&*I) T();
-      this->set_size(N);
-    }
-  }
-
-  void resize(size_type N, const T &NV) {
-    if (N < this->size()) {
-      this->destroy_range(this->begin()+N, this->end());
-      this->set_size(N);
-    } else if (N > this->size()) {
-      if (this->capacity() < N)
-        this->grow(N);
-      std::uninitialized_fill(this->end(), this->begin()+N, NV);
-      this->set_size(N);
-    }
-  }
-
-  void reserve(size_type N) {
-    if (this->capacity() < N)
-      this->grow(N);
-  }
-
-  LLVM_NODISCARD T pop_back_val() {
-    T Result = ::std::move(this->back());
-    this->pop_back();
-    return Result;
-  }
-
-  void swap(SmallVectorImpl &RHS);
-
-  /// Add the specified range to the end of the SmallVector.
-  template <typename in_iter,
-            typename = typename std::enable_if<std::is_convertible<
-                typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>::type>
-  void append(in_iter in_start, in_iter in_end) {
-    size_type NumInputs = std::distance(in_start, in_end);
-    // Grow allocated space if needed.
-    if (NumInputs > this->capacity() - this->size())
-      this->grow(this->size()+NumInputs);
-
-    // Copy the new elements over.
-    this->uninitialized_copy(in_start, in_end, this->end());
-    this->set_size(this->size() + NumInputs);
-  }
-
-  /// Add the specified range to the end of the SmallVector.
-  void append(size_type NumInputs, const T &Elt) {
-    // Grow allocated space if needed.
-    if (NumInputs > this->capacity() - this->size())
-      this->grow(this->size()+NumInputs);
-
-    // Copy the new elements over.
-    std::uninitialized_fill_n(this->end(), NumInputs, Elt);
-    this->set_size(this->size() + NumInputs);
-  }
-
-  void append(std::initializer_list<T> IL) {
-    append(IL.begin(), IL.end());
-  }
-
-  // FIXME: Consider assigning over existing elements, rather than clearing &
-  // re-initializing them - for all assign(...) variants.
-
-  void assign(size_type NumElts, const T &Elt) {
-    clear();
-    if (this->capacity() < NumElts)
-      this->grow(NumElts);
-    this->set_size(NumElts);
-    std::uninitialized_fill(this->begin(), this->end(), Elt);
-  }
-
-  template <typename in_iter,
-            typename = typename std::enable_if<std::is_convertible<
-                typename std::iterator_traits<in_iter>::iterator_category,
-                std::input_iterator_tag>::value>::type>
-  void assign(in_iter in_start, in_iter in_end) {
-    clear();
-    append(in_start, in_end);
-  }
-
-  void assign(std::initializer_list<T> IL) {
-    clear();
-    append(IL);
-  }
-
-  iterator erase(const_iterator CI) {
-    // Just cast away constness because this is a non-const member function.
-    iterator I = const_cast<iterator>(CI);
-
-    assert(I >= this->begin() && "Iterator to erase is out of bounds.");
-    assert(I < this->end() && "Erasing at past-the-end iterator.");
-
-    iterator N = I;
-    // Shift all elts down one.
-    std::move(I+1, this->end(), I);
-    // Drop the last elt.
-    this->pop_back();
-    return(N);
-  }
-
-  iterator erase(const_iterator CS, const_iterator CE) {
-    // Just cast away constness because this is a non-const member function.
-    iterator S = const_cast<iterator>(CS);
-    iterator E = const_cast<iterator>(CE);
-
-    assert(S >= this->begin() && "Range to erase is out of bounds.");
-    assert(S <= E && "Trying to erase invalid range.");
-    assert(E <= this->end() && "Trying to erase past the end.");
-
-    iterator N = S;
-    // Shift all elts down.
-    iterator I = std::move(E, this->end(), S);
-    // Drop the last elts.
-    this->destroy_range(I, this->end());
-    this->set_size(I - this->begin());
-    return(N);
-  }
-
-  iterator insert(iterator I, T &&Elt) {
-    if (I == this->end()) {  // Important special case for empty vector.
-      this->push_back(::std::move(Elt));
-      return this->end()-1;
-    }
-
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
-
-    if (this->size() >= this->capacity()) {
-      size_t EltNo = I-this->begin();
-      this->grow();
-      I = this->begin()+EltNo;
-    }
-
-    ::new ((void*) this->end()) T(::std::move(this->back()));
-    // Push everything else over.
-    std::move_backward(I, this->end()-1, this->end());
-    this->set_size(this->size() + 1);
-
-    // If we just moved the element we're inserting, be sure to update
-    // the reference.
-    T *EltPtr = &Elt;
-    if (I <= EltPtr && EltPtr < this->end())
-      ++EltPtr;
-
-    *I = ::std::move(*EltPtr);
-    return I;
-  }
-
-  iterator insert(iterator I, const T &Elt) {
-    if (I == this->end()) {  // Important special case for empty vector.
-      this->push_back(Elt);
-      return this->end()-1;
-    }
-
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
-
-    if (this->size() >= this->capacity()) {
-      size_t EltNo = I-this->begin();
-      this->grow();
-      I = this->begin()+EltNo;
-    }
-    ::new ((void*) this->end()) T(std::move(this->back()));
-    // Push everything else over.
-    std::move_backward(I, this->end()-1, this->end());
-    this->set_size(this->size() + 1);
-
-    // If we just moved the element we're inserting, be sure to update
-    // the reference.
-    const T *EltPtr = &Elt;
-    if (I <= EltPtr && EltPtr < this->end())
-      ++EltPtr;
-
-    *I = *EltPtr;
-    return I;
-  }
-
-  iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
-    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I - this->begin();
-
-    if (I == this->end()) {  // Important special case for empty vector.
-      append(NumToInsert, Elt);
-      return this->begin()+InsertElt;
-    }
-
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
-
-    // Ensure there is enough space.
-    reserve(this->size() + NumToInsert);
-
-    // Uninvalidate the iterator.
-    I = this->begin()+InsertElt;
-
-    // If there are more elements between the insertion point and the end of the
-    // range than there are being inserted, we can use a simple approach to
-    // insertion.  Since we already reserved space, we know that this won't
-    // reallocate the vector.
-    if (size_t(this->end()-I) >= NumToInsert) {
-      T *OldEnd = this->end();
-      append(std::move_iterator<iterator>(this->end() - NumToInsert),
-             std::move_iterator<iterator>(this->end()));
-
-      // Copy the existing elements that get replaced.
-      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
-
-      std::fill_n(I, NumToInsert, Elt);
-      return I;
-    }
-
-    // Otherwise, we're inserting more elements than exist already, and we're
-    // not inserting at the end.
-
-    // Move over the elements that we're about to overwrite.
-    T *OldEnd = this->end();
-    this->set_size(this->size() + NumToInsert);
-    size_t NumOverwritten = OldEnd-I;
-    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
-
-    // Replace the overwritten part.
-    std::fill_n(I, NumOverwritten, Elt);
-
-    // Insert the non-overwritten middle part.
-    std::uninitialized_fill_n(OldEnd, NumToInsert-NumOverwritten, Elt);
-    return I;
-  }
-
-  template <typename ItTy,
-            typename = typename std::enable_if<std::is_convertible<
-                typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>::type>
-  iterator insert(iterator I, ItTy From, ItTy To) {
-    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    size_t InsertElt = I - this->begin();
-
-    if (I == this->end()) {  // Important special case for empty vector.
-      append(From, To);
-      return this->begin()+InsertElt;
-    }
-
-    assert(I >= this->begin() && "Insertion iterator is out of bounds.");
-    assert(I <= this->end() && "Inserting past the end of the vector.");
-
-    size_t NumToInsert = std::distance(From, To);
-
-    // Ensure there is enough space.
-    reserve(this->size() + NumToInsert);
-
-    // Uninvalidate the iterator.
-    I = this->begin()+InsertElt;
-
-    // If there are more elements between the insertion point and the end of the
-    // range than there are being inserted, we can use a simple approach to
-    // insertion.  Since we already reserved space, we know that this won't
-    // reallocate the vector.
-    if (size_t(this->end()-I) >= NumToInsert) {
-      T *OldEnd = this->end();
-      append(std::move_iterator<iterator>(this->end() - NumToInsert),
-             std::move_iterator<iterator>(this->end()));
-
-      // Copy the existing elements that get replaced.
-      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
-
-      std::copy(From, To, I);
-      return I;
-    }
-
-    // Otherwise, we're inserting more elements than exist already, and we're
-    // not inserting at the end.
-
-    // Move over the elements that we're about to overwrite.
-    T *OldEnd = this->end();
-    this->set_size(this->size() + NumToInsert);
-    size_t NumOverwritten = OldEnd-I;
-    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
-
-    // Replace the overwritten part.
-    for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
-      *J = *From;
-      ++J; ++From;
-    }
-
-    // Insert the non-overwritten middle part.
-    this->uninitialized_copy(From, To, OldEnd);
-    return I;
-  }
-
-  void insert(iterator I, std::initializer_list<T> IL) {
-    insert(I, IL.begin(), IL.end());
-  }
-
-  template <typename... ArgTypes> void emplace_back(ArgTypes &&... Args) {
-    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
-      this->grow();
-    ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
-    this->set_size(this->size() + 1);
-  }
-
-  SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
-
-  SmallVectorImpl &operator=(SmallVectorImpl &&RHS);
-
-  bool operator==(const SmallVectorImpl &RHS) const {
-    if (this->size() != RHS.size()) return false;
-    return std::equal(this->begin(), this->end(), RHS.begin());
-  }
-  bool operator!=(const SmallVectorImpl &RHS) const {
-    return !(*this == RHS);
-  }
-
-  bool operator<(const SmallVectorImpl &RHS) const {
-    return std::lexicographical_compare(this->begin(), this->end(),
-                                        RHS.begin(), RHS.end());
-  }
-};
-
-template <typename T>
-void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
-  if (this == &RHS) return;
-
-  // We can only avoid copying elements if neither vector is small.
-  if (!this->isSmall() && !RHS.isSmall()) {
-    std::swap(this->BeginX, RHS.BeginX);
-    std::swap(this->Size, RHS.Size);
-    std::swap(this->Capacity, RHS.Capacity);
-    return;
-  }
-  if (RHS.size() > this->capacity())
-    this->grow(RHS.size());
-  if (this->size() > RHS.capacity())
-    RHS.grow(this->size());
-
-  // Swap the shared elements.
-  size_t NumShared = this->size();
-  if (NumShared > RHS.size()) NumShared = RHS.size();
-  for (size_type i = 0; i != NumShared; ++i)
-    std::swap((*this)[i], RHS[i]);
-
-  // Copy over the extra elts.
-  if (this->size() > RHS.size()) {
-    size_t EltDiff = this->size() - RHS.size();
-    this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
-    RHS.set_size(RHS.size() + EltDiff);
-    this->destroy_range(this->begin()+NumShared, this->end());
-    this->set_size(NumShared);
-  } else if (RHS.size() > this->size()) {
-    size_t EltDiff = RHS.size() - this->size();
-    this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
-    this->set_size(this->size() + EltDiff);
-    this->destroy_range(RHS.begin()+NumShared, RHS.end());
-    RHS.set_size(NumShared);
-  }
-}
-
-template <typename T>
-SmallVectorImpl<T> &SmallVectorImpl<T>::
-  operator=(const SmallVectorImpl<T> &RHS) {
-  // Avoid self-assignment.
-  if (this == &RHS) return *this;
-
-  // If we already have sufficient space, assign the common elements, then
-  // destroy any excess.
-  size_t RHSSize = RHS.size();
-  size_t CurSize = this->size();
-  if (CurSize >= RHSSize) {
-    // Assign common elements.
-    iterator NewEnd;
-    if (RHSSize)
-      NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
-    else
-      NewEnd = this->begin();
-
-    // Destroy excess elements.
-    this->destroy_range(NewEnd, this->end());
-
-    // Trim.
-    this->set_size(RHSSize);
-    return *this;
-  }
-
-  // If we have to grow to have enough elements, destroy the current elements.
-  // This allows us to avoid copying them during the grow.
-  // FIXME: don't do this if they're efficiently moveable.
-  if (this->capacity() < RHSSize) {
-    // Destroy current elements.
-    this->destroy_range(this->begin(), this->end());
-    this->set_size(0);
-    CurSize = 0;
-    this->grow(RHSSize);
-  } else if (CurSize) {
-    // Otherwise, use assignment for the already-constructed elements.
-    std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
-  }
-
-  // Copy construct the new elements in place.
-  this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
-                           this->begin()+CurSize);
-
-  // Set end.
-  this->set_size(RHSSize);
-  return *this;
-}
-
-template <typename T>
-SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
-  // Avoid self-assignment.
-  if (this == &RHS) return *this;
-
-  // If the RHS isn't small, clear this vector and then steal its buffer.
-  if (!RHS.isSmall()) {
-    this->destroy_range(this->begin(), this->end());
-    if (!this->isSmall()) free(this->begin());
-    this->BeginX = RHS.BeginX;
-    this->Size = RHS.Size;
-    this->Capacity = RHS.Capacity;
-    RHS.resetToSmall();
-    return *this;
-  }
-
-  // If we already have sufficient space, assign the common elements, then
-  // destroy any excess.
-  size_t RHSSize = RHS.size();
-  size_t CurSize = this->size();
-  if (CurSize >= RHSSize) {
-    // Assign common elements.
-    iterator NewEnd = this->begin();
-    if (RHSSize)
-      NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
-
-    // Destroy excess elements and trim the bounds.
-    this->destroy_range(NewEnd, this->end());
-    this->set_size(RHSSize);
-
-    // Clear the RHS.
-    RHS.clear();
-
-    return *this;
-  }
-
-  // If we have to grow to have enough elements, destroy the current elements.
-  // This allows us to avoid copying them during the grow.
-  // FIXME: this may not actually make any sense if we can efficiently move
-  // elements.
-  if (this->capacity() < RHSSize) {
-    // Destroy current elements.
-    this->destroy_range(this->begin(), this->end());
-    this->set_size(0);
-    CurSize = 0;
-    this->grow(RHSSize);
-  } else if (CurSize) {
-    // Otherwise, use assignment for the already-constructed elements.
-    std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
-  }
-
-  // Move-construct the new elements in place.
-  this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
-                           this->begin()+CurSize);
-
-  // Set end.
-  this->set_size(RHSSize);
-
-  RHS.clear();
-  return *this;
-}
-
-/// Storage for the SmallVector elements.  This is specialized for the N=0 case
-/// to avoid allocating unnecessary storage.
-template <typename T, unsigned N>
-struct SmallVectorStorage {
-  AlignedCharArrayUnion<T> InlineElts[N];
-};
-
-/// We need the storage to be properly aligned even for small-size of 0 so that
-/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
-/// well-defined.
-template <typename T> struct alignas(alignof(T)) SmallVectorStorage<T, 0> {};
-
-/// This is a 'vector' (really, a variable-sized array), optimized
-/// for the case when the array is small.  It contains some number of elements
-/// in-place, which allows it to avoid heap allocation when the actual number of
-/// elements is below that threshold.  This allows normal "small" cases to be
-/// fast without losing generality for large inputs.
-///
-/// Note that this does not attempt to be exception safe.
-///
-template <typename T, unsigned N>
-class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
-public:
-  SmallVector() : SmallVectorImpl<T>(N) {}
-
-  ~SmallVector() {
-    // Destroy the constructed elements in the vector.
-    this->destroy_range(this->begin(), this->end());
-  }
-
-  explicit SmallVector(size_t Size, const T &Value = T())
-    : SmallVectorImpl<T>(N) {
-    this->assign(Size, Value);
-  }
-
-  template <typename ItTy,
-            typename = typename std::enable_if<std::is_convertible<
-                typename std::iterator_traits<ItTy>::iterator_category,
-                std::input_iterator_tag>::value>::type>
-  SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
-    this->append(S, E);
-  }
-
-  template <typename RangeTy>
-  explicit SmallVector(const iterator_range<RangeTy> &R)
-      : SmallVectorImpl<T>(N) {
-    this->append(R.begin(), R.end());
-  }
-
-  SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
-    this->assign(IL);
-  }
-
-  SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(RHS);
-  }
-
-  const SmallVector &operator=(const SmallVector &RHS) {
-    SmallVectorImpl<T>::operator=(RHS);
-    return *this;
-  }
-
-  SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(::std::move(RHS));
-  }
-
-  SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
-    if (!RHS.empty())
-      SmallVectorImpl<T>::operator=(::std::move(RHS));
-  }
-
-  const SmallVector &operator=(SmallVector &&RHS) {
-    SmallVectorImpl<T>::operator=(::std::move(RHS));
-    return *this;
-  }
-
-  const SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
-    SmallVectorImpl<T>::operator=(::std::move(RHS));
-    return *this;
-  }
-
-  const SmallVector &operator=(std::initializer_list<T> IL) {
-    this->assign(IL);
-    return *this;
-  }
-};
-
-template <typename T, unsigned N>
-inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
-  return X.capacity_in_bytes();
-}
-
-} // end namespace wpi
-
-namespace std {
-
-  /// Implement std::swap in terms of SmallVector swap.
-  template<typename T>
-  inline void
-  swap(wpi::SmallVectorImpl<T> &LHS, wpi::SmallVectorImpl<T> &RHS) {
-    LHS.swap(RHS);
-  }
-
-  /// Implement std::swap in terms of SmallVector swap.
-  template<typename T, unsigned N>
-  inline void
-  swap(wpi::SmallVector<T, N> &LHS, wpi::SmallVector<T, N> &RHS) {
-    LHS.swap(RHS);
-  }
-
-} // end namespace std
-
-#endif // LLVM_ADT_SMALLVECTOR_H
diff --git a/wpiutil/src/main/native/include/wpi/SocketError.h b/wpiutil/src/main/native/include/wpi/SocketError.h
deleted file mode 100644
index b893ac6..0000000
--- a/wpiutil/src/main/native/include/wpi/SocketError.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_SOCKETERROR_H_
-#define WPIUTIL_WPI_SOCKETERROR_H_
-
-#include <string>
-
-namespace wpi {
-
-int SocketErrno();
-
-std::string SocketStrerror(int code);
-
-inline std::string SocketStrerror() {
-  return SocketStrerror(SocketErrno());
-}
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_SOCKETERROR_H_
diff --git a/wpiutil/src/main/native/include/wpi/SpanExtras.h b/wpiutil/src/main/native/include/wpi/SpanExtras.h
index 41e4014..aa7b9ab 100644
--- a/wpiutil/src/main/native/include/wpi/SpanExtras.h
+++ b/wpiutil/src/main/native/include/wpi/SpanExtras.h
@@ -5,21 +5,22 @@
 #pragma once
 
 #include <cassert>
-
-#include "wpi/span.h"
+#include <span>
 
 namespace wpi {
 
 /// Drop the first \p N elements of the array.
 template <typename T>
-constexpr span<T> drop_front(span<T> in, typename span<T>::size_type n = 1) {
+constexpr std::span<T> drop_front(std::span<T> in,
+                                  typename std::span<T>::size_type n = 1) {
   assert(in.size() >= n && "Dropping more elements than exist");
   return in.subspan(n, in.size() - n);
 }
 
 /// Drop the last \p N elements of the array.
 template <typename T>
-constexpr span<T> drop_back(span<T> in, typename span<T>::size_type n = 1) {
+constexpr std::span<T> drop_back(std::span<T> in,
+                                 typename std::span<T>::size_type n = 1) {
   assert(in.size() >= n && "Dropping more elements than exist");
   return in.subspan(0, in.size() - n);
 }
diff --git a/wpiutil/src/main/native/include/wpi/SwapByteOrder.h b/wpiutil/src/main/native/include/wpi/SwapByteOrder.h
deleted file mode 100644
index 50ad832..0000000
--- a/wpiutil/src/main/native/include/wpi/SwapByteOrder.h
+++ /dev/null
@@ -1,127 +0,0 @@
-//===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares generic and optimized functions to swap the byte order of
-// an integral type.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_SWAPBYTEORDER_H
-#define WPIUTIL_WPI_SWAPBYTEORDER_H
-
-#include "wpi/Compiler.h"
-#include <cstddef>
-#include <stdint.h>
-#if defined(_MSC_VER) && !defined(_DEBUG)
-#include <stdlib.h>
-#endif
-
-namespace wpi {
-namespace sys {
-
-/// SwapByteOrder_16 - This function returns a byte-swapped representation of
-/// the 16-bit argument.
-inline uint16_t SwapByteOrder_16(uint16_t value) {
-#if defined(_MSC_VER) && !defined(_DEBUG)
-  // The DLL version of the runtime lacks these functions (bug!?), but in a
-  // release build they're replaced with BSWAP instructions anyway.
-  return _byteswap_ushort(value);
-#else
-  uint16_t Hi = value << 8;
-  uint16_t Lo = value >> 8;
-  return Hi | Lo;
-#endif
-}
-
-/// SwapByteOrder_32 - This function returns a byte-swapped representation of
-/// the 32-bit argument.
-inline uint32_t SwapByteOrder_32(uint32_t value) {
-#if defined(__llvm__) || (LLVM_GNUC_PREREQ(4, 3, 0) && !defined(__ICC))
-  return __builtin_bswap32(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_ulong(value);
-#else
-  uint32_t Byte0 = value & 0x000000FF;
-  uint32_t Byte1 = value & 0x0000FF00;
-  uint32_t Byte2 = value & 0x00FF0000;
-  uint32_t Byte3 = value & 0xFF000000;
-  return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
-#endif
-}
-
-/// SwapByteOrder_64 - This function returns a byte-swapped representation of
-/// the 64-bit argument.
-inline uint64_t SwapByteOrder_64(uint64_t value) {
-#if defined(__llvm__) || (LLVM_GNUC_PREREQ(4, 3, 0) && !defined(__ICC))
-  return __builtin_bswap64(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_uint64(value);
-#else
-  uint64_t Hi = SwapByteOrder_32(uint32_t(value));
-  uint32_t Lo = SwapByteOrder_32(uint32_t(value >> 32));
-  return (Hi << 32) | Lo;
-#endif
-}
-
-inline unsigned char  getSwappedBytes(unsigned char C) { return C; }
-inline   signed char  getSwappedBytes(signed char C) { return C; }
-inline          char  getSwappedBytes(char C) { return C; }
-
-inline unsigned short getSwappedBytes(unsigned short C) { return SwapByteOrder_16(C); }
-inline   signed short getSwappedBytes(  signed short C) { return SwapByteOrder_16(C); }
-
-inline unsigned int   getSwappedBytes(unsigned int   C) { return SwapByteOrder_32(C); }
-inline   signed int   getSwappedBytes(  signed int   C) { return SwapByteOrder_32(C); }
-
-#if __LONG_MAX__ == __INT_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_32(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_32(C); }
-#elif __LONG_MAX__ == __LONG_LONG_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_64(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_64(C); }
-#else
-#error "Unknown long size!"
-#endif
-
-inline unsigned long long getSwappedBytes(unsigned long long C) {
-  return SwapByteOrder_64(C);
-}
-inline signed long long getSwappedBytes(signed long long C) {
-  return SwapByteOrder_64(C);
-}
-
-inline float getSwappedBytes(float C) {
-  union {
-    uint32_t i;
-    float f;
-  } in, out;
-  in.f = C;
-  out.i = SwapByteOrder_32(in.i);
-  return out.f;
-}
-
-inline double getSwappedBytes(double C) {
-  union {
-    uint64_t i;
-    double d;
-  } in, out;
-  in.d = C;
-  out.i = SwapByteOrder_64(in.i);
-  return out.d;
-}
-
-template<typename T>
-inline void swapByteOrder(T &Value) {
-  Value = getSwappedBytes(Value);
-}
-
-} // end namespace sys
-} // end namespace wpi
-
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/SymbolExports.h b/wpiutil/src/main/native/include/wpi/SymbolExports.h
index 4e84825..9ffc936 100644
--- a/wpiutil/src/main/native/include/wpi/SymbolExports.h
+++ b/wpiutil/src/main/native/include/wpi/SymbolExports.h
@@ -14,10 +14,179 @@
 #define WPILIB_DLLEXPORT __declspec(dllexport)
 #endif
 
+#elif defined(WPILIB_IMPORTS)
+
+#ifdef __GNUC__
+#define WPILIB_DLLEXPORT __attribute__((dllimport))
+#else
+#define WPILIB_DLLEXPORT __declspec(dllimport)
+#endif
+
 #else
 #define WPILIB_DLLEXPORT
 #endif
 
-#else
+#else  // _WIN32
+
+#ifdef WPILIB_EXPORTS
 #define WPILIB_DLLEXPORT __attribute__((visibility("default")))
+#else
+#define WPILIB_DLLEXPORT
 #endif
+
+#endif  // _WIN32
+
+// Synopsis
+//
+// This header provides macros for using FOO_EXPORT macros with explicit
+// template instantiation declarations and definitions.
+// Generally, the FOO_EXPORT macros are used at declarations,
+// and GCC requires them to be used at explicit instantiation declarations,
+// but MSVC requires __declspec(dllexport) to be used at the explicit
+// instantiation definitions instead.
+
+// Usage
+//
+// In a header file, write:
+//
+//   extern template class EXPORT_TEMPLATE_DECLARE(FOO_EXPORT) foo<bar>;
+//
+// In a source file, write:
+//
+//   template class EXPORT_TEMPLATE_DEFINE(FOO_EXPORT) foo<bar>;
+
+// Implementation notes
+//
+// The implementation of this header uses some subtle macro semantics to
+// detect what the provided FOO_EXPORT value was defined as and then
+// to dispatch to appropriate macro definitions.  Unfortunately,
+// MSVC's C preprocessor is rather non-compliant and requires special
+// care to make it work.
+//
+// Issue 1.
+//
+//   #define F(x)
+//   F()
+//
+// MSVC emits warning C4003 ("not enough actual parameters for macro
+// 'F'), even though it's a valid macro invocation.  This affects the
+// macros below that take just an "export" parameter, because export
+// may be empty.
+//
+// As a workaround, we can add a dummy parameter and arguments:
+//
+//   #define F(x,_)
+//   F(,)
+//
+// Issue 2.
+//
+//   #define F(x) G##x
+//   #define Gj() ok
+//   F(j())
+//
+// The correct replacement for "F(j())" is "ok", but MSVC replaces it
+// with "Gj()".  As a workaround, we can pass the result to an
+// identity macro to force MSVC to look for replacements again.  (This
+// is why EXPORT_TEMPLATE_STYLE_3 exists.)
+
+#define EXPORT_TEMPLATE_DECLARE(export) \
+  EXPORT_TEMPLATE_INVOKE(DECLARE, EXPORT_TEMPLATE_STYLE(export, ), export)
+#define EXPORT_TEMPLATE_DEFINE(export) \
+  EXPORT_TEMPLATE_INVOKE(DEFINE, EXPORT_TEMPLATE_STYLE(export, ), export)
+
+// INVOKE is an internal helper macro to perform parameter replacements
+// and token pasting to chain invoke another macro.  E.g.,
+//     EXPORT_TEMPLATE_INVOKE(DECLARE, DEFAULT, FOO_EXPORT)
+// will export to call
+//     EXPORT_TEMPLATE_DECLARE_DEFAULT(FOO_EXPORT, )
+// (but with FOO_EXPORT expanded too).
+#define EXPORT_TEMPLATE_INVOKE(which, style, export) \
+  EXPORT_TEMPLATE_INVOKE_2(which, style, export)
+#define EXPORT_TEMPLATE_INVOKE_2(which, style, export) \
+  EXPORT_TEMPLATE_##which##_##style(export, )
+
+// Default style is to apply the FOO_EXPORT macro at declaration sites.
+#define EXPORT_TEMPLATE_DECLARE_DEFAULT(export, _) export
+#define EXPORT_TEMPLATE_DEFINE_DEFAULT(export, _)
+
+// The "MSVC hack" style is used when FOO_EXPORT is defined
+// as __declspec(dllexport), which MSVC requires to be used at
+// definition sites instead.
+#define EXPORT_TEMPLATE_DECLARE_MSVC_HACK(export, _)
+#define EXPORT_TEMPLATE_DEFINE_MSVC_HACK(export, _) export
+
+// EXPORT_TEMPLATE_STYLE is an internal helper macro that identifies which
+// export style needs to be used for the provided FOO_EXPORT macro definition.
+// "", "__attribute__(...)", and "__declspec(dllimport)" are mapped
+// to "DEFAULT"; while "__declspec(dllexport)" is mapped to "MSVC_HACK".
+//
+// It's implemented with token pasting to transform the __attribute__ and
+// __declspec annotations into macro invocations.  E.g., if FOO_EXPORT is
+// defined as "__declspec(dllimport)", it undergoes the following sequence of
+// macro substitutions:
+//     EXPORT_TEMPLATE_STYLE(FOO_EXPORT, )
+//     EXPORT_TEMPLATE_STYLE_2(__declspec(dllimport), )
+//     EXPORT_TEMPLATE_STYLE_3(EXPORT_TEMPLATE_STYLE_MATCH__declspec(dllimport))
+//     EXPORT_TEMPLATE_STYLE_MATCH__declspec(dllimport)
+//     EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllimport
+//     DEFAULT
+#define EXPORT_TEMPLATE_STYLE(export, _) EXPORT_TEMPLATE_STYLE_2(export, )
+#define EXPORT_TEMPLATE_STYLE_2(export, _) \
+  EXPORT_TEMPLATE_STYLE_3(                 \
+      EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA##export)
+#define EXPORT_TEMPLATE_STYLE_3(style) style
+
+// Internal helper macros for EXPORT_TEMPLATE_STYLE.
+//
+// XXX: C++ reserves all identifiers containing "__" for the implementation,
+// but "__attribute__" and "__declspec" already contain "__" and the token-paste
+// operator can only add characters; not remove them.  To minimize the risk of
+// conflict with implementations, we include "foj3FJo5StF0OvIzl7oMxA" (a random
+// 128-bit string, encoded in Base64) in the macro name.
+#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA DEFAULT
+#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA__attribute__(...) \
+  DEFAULT
+#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA__declspec(arg) \
+  EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_##arg
+
+// Internal helper macros for EXPORT_TEMPLATE_STYLE.
+#define EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllexport MSVC_HACK
+#define EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllimport DEFAULT
+
+// Sanity checks.
+//
+// EXPORT_TEMPLATE_TEST uses the same macro invocation pattern as
+// EXPORT_TEMPLATE_DECLARE and EXPORT_TEMPLATE_DEFINE do to check that they're
+// working correctly.  When they're working correctly, the sequence of macro
+// replacements should go something like:
+//
+//     EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport));
+//
+//     static_assert(EXPORT_TEMPLATE_INVOKE(TEST_DEFAULT,
+//         EXPORT_TEMPLATE_STYLE(__declspec(dllimport), ),
+//         __declspec(dllimport)), "__declspec(dllimport)");
+//
+//     static_assert(EXPORT_TEMPLATE_INVOKE(TEST_DEFAULT,
+//         DEFAULT, __declspec(dllimport)), "__declspec(dllimport)");
+//
+//     static_assert(EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT(
+//         __declspec(dllimport)), "__declspec(dllimport)");
+//
+//     static_assert(true, "__declspec(dllimport)");
+//
+// When they're not working correctly, a syntax error should occur instead.
+#define EXPORT_TEMPLATE_TEST(want, export)                                 \
+  static_assert(EXPORT_TEMPLATE_INVOKE(                                    \
+                    TEST_##want, EXPORT_TEMPLATE_STYLE(export, ), export), \
+                #export)
+#define EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT(...) true
+#define EXPORT_TEMPLATE_TEST_MSVC_HACK_MSVC_HACK(...) true
+
+EXPORT_TEMPLATE_TEST(DEFAULT, );
+EXPORT_TEMPLATE_TEST(DEFAULT, __attribute__((visibility("default"))));
+EXPORT_TEMPLATE_TEST(MSVC_HACK, __declspec(dllexport));
+EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport));
+
+#undef EXPORT_TEMPLATE_TEST
+#undef EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT
+#undef EXPORT_TEMPLATE_TEST_MSVC_HACK_MSVC_HACK
diff --git a/wpiutil/src/main/native/include/wpi/Synchronization.h b/wpiutil/src/main/native/include/wpi/Synchronization.h
index 57fc4ee..4ac3c8c 100644
--- a/wpiutil/src/main/native/include/wpi/Synchronization.h
+++ b/wpiutil/src/main/native/include/wpi/Synchronization.h
@@ -4,12 +4,11 @@
 
 #pragma once
 
+#ifdef __cplusplus
 #include <climits>  // NOLINT
 
-#ifdef __cplusplus
 #include <initializer_list>
-
-#include "wpi/span.h"
+#include <span>
 #endif
 
 /**
@@ -43,8 +42,8 @@
 constexpr int kHandleTypeSemaphore = 2;
 constexpr int kHandleTypeCSBase = 3;
 constexpr int kHandleTypeNTBase = 16;
-constexpr int kHandleTypeHALBase = 32;
-constexpr int kHandleTypeUserBase = 64;
+constexpr int kHandleTypeHALBase = 48;
+constexpr int kHandleTypeUserBase = 80;
 /** @} */
 
 /**
@@ -149,8 +148,8 @@
  *        least the size of the handles input array
  * @return array of signaled handles (points into signaled array)
  */
-wpi::span<WPI_Handle> WaitForObjects(wpi::span<const WPI_Handle> handles,
-                                     wpi::span<WPI_Handle> signaled);
+std::span<WPI_Handle> WaitForObjects(std::span<const WPI_Handle> handles,
+                                     std::span<WPI_Handle> signaled);
 
 /**
  * Waits for one or more handles to be signaled.
@@ -163,9 +162,9 @@
  *        least the size of the handles input array
  * @return array of signaled handles (points into signaled array)
  */
-inline wpi::span<WPI_Handle> WaitForObjects(
-    std::initializer_list<WPI_Handle> handles, wpi::span<WPI_Handle> signaled) {
-  return WaitForObjects(wpi::span{handles.begin(), handles.size()}, signaled);
+inline std::span<WPI_Handle> WaitForObjects(
+    std::initializer_list<WPI_Handle> handles, std::span<WPI_Handle> signaled) {
+  return WaitForObjects(std::span{handles.begin(), handles.size()}, signaled);
 }
 
 /**
@@ -182,8 +181,8 @@
  *        handle being signaled; set to false otherwise (output)
  * @return array of signaled handles (points into signaled array)
  */
-wpi::span<WPI_Handle> WaitForObjects(wpi::span<const WPI_Handle> handles,
-                                     wpi::span<WPI_Handle> signaled,
+std::span<WPI_Handle> WaitForObjects(std::span<const WPI_Handle> handles,
+                                     std::span<WPI_Handle> signaled,
                                      double timeout, bool* timedOut);
 /**
  * Waits for one or more handles to be signaled, with timeout.
@@ -199,10 +198,10 @@
  *        handle being signaled; set to false otherwise (output)
  * @return array of signaled handles (points into signaled array)
  */
-inline wpi::span<WPI_Handle> WaitForObjects(
-    std::initializer_list<WPI_Handle> handles, wpi::span<WPI_Handle> signaled,
+inline std::span<WPI_Handle> WaitForObjects(
+    std::initializer_list<WPI_Handle> handles, std::span<WPI_Handle> signaled,
     double timeout, bool* timedOut) {
-  return WaitForObjects(wpi::span{handles.begin(), handles.size()}, signaled,
+  return WaitForObjects(std::span{handles.begin(), handles.size()}, signaled,
                         timeout, timedOut);
 }
 
diff --git a/wpiutil/src/main/native/include/wpi/TCPAcceptor.h b/wpiutil/src/main/native/include/wpi/TCPAcceptor.h
deleted file mode 100644
index 083897a..0000000
--- a/wpiutil/src/main/native/include/wpi/TCPAcceptor.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
-   TCPAcceptor.h
-
-   TCPAcceptor class interface. TCPAcceptor provides methods to passively
-   establish TCP/IP connections with clients.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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.
-*/
-
-#ifndef WPIUTIL_WPI_TCPACCEPTOR_H_
-#define WPIUTIL_WPI_TCPACCEPTOR_H_
-
-#include <atomic>
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/NetworkAcceptor.h"
-#include "wpi/TCPStream.h"
-
-namespace wpi {
-
-class Logger;
-
-class TCPAcceptor : public NetworkAcceptor {
-  int m_lsd;
-  int m_port;
-  std::string m_address;
-  bool m_listening;
-  std::atomic_bool m_shutdown;
-  Logger& m_logger;
-
- public:
-  TCPAcceptor(int port, std::string_view address, Logger& logger);
-  ~TCPAcceptor() override;
-
-  int start() override;
-  void shutdown() final;
-  std::unique_ptr<NetworkStream> accept() override;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_TCPACCEPTOR_H_
diff --git a/wpiutil/src/main/native/include/wpi/TCPConnector.h b/wpiutil/src/main/native/include/wpi/TCPConnector.h
deleted file mode 100644
index 63e8906..0000000
--- a/wpiutil/src/main/native/include/wpi/TCPConnector.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-   TCPConnector.h
-
-   TCPConnector class interface. TCPConnector provides methods to actively
-   establish TCP/IP connections with a server.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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
-*/
-
-#ifndef WPIUTIL_WPI_TCPCONNECTOR_H_
-#define WPIUTIL_WPI_TCPCONNECTOR_H_
-
-#include <memory>
-#include <utility>
-
-#include "wpi/NetworkStream.h"
-#include "wpi/span.h"
-
-namespace wpi {
-
-class Logger;
-
-class TCPConnector {
- public:
-  static std::unique_ptr<NetworkStream> connect(const char* server, int port,
-                                                Logger& logger,
-                                                int timeout = 0);
-  static std::unique_ptr<NetworkStream> connect_parallel(
-      span<const std::pair<const char*, int>> servers, Logger& logger,
-      int timeout = 0);
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_TCPCONNECTOR_H_
diff --git a/wpiutil/src/main/native/include/wpi/TCPStream.h b/wpiutil/src/main/native/include/wpi/TCPStream.h
deleted file mode 100644
index 2d54300..0000000
--- a/wpiutil/src/main/native/include/wpi/TCPStream.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
-   TCPStream.h
-
-   TCPStream class interface. TCPStream provides methods to transfer
-   data between peers over a TCP/IP connection.
-
-   ------------------------------------------
-
-   Copyright (c) 2013 [Vic Hargrave - http://vichargrave.com]
-
-   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.
-*/
-
-#ifndef WPIUTIL_WPI_TCPSTREAM_H_
-#define WPIUTIL_WPI_TCPSTREAM_H_
-
-#include <cstddef>
-#include <string>
-#include <string_view>
-
-#include "wpi/NetworkStream.h"
-
-struct sockaddr_in;
-
-namespace wpi {
-
-class TCPStream : public NetworkStream {
-  int m_sd;
-  std::string m_peerIP;
-  int m_peerPort;
-  bool m_blocking;
-
- public:
-  friend class TCPAcceptor;
-  friend class TCPConnector;
-
-  ~TCPStream() override;
-
-  size_t send(const char* buffer, size_t len, Error* err) override;
-  size_t receive(char* buffer, size_t len, Error* err,
-                 int timeout = 0) override;
-  void close() final;
-
-  std::string_view getPeerIP() const override;
-  int getPeerPort() const override;
-  void setNoDelay() override;
-  bool setBlocking(bool enabled) override;
-  int getNativeHandle() const override;
-
-  TCPStream(const TCPStream& stream) = delete;
-  TCPStream& operator=(const TCPStream&) = delete;
-
- private:
-  bool WaitForReadEvent(int timeout);
-
-  TCPStream(int sd, sockaddr_in* address);
-  TCPStream() = delete;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_TCPSTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/UDPClient.h b/wpiutil/src/main/native/include/wpi/UDPClient.h
deleted file mode 100644
index fd2e30b..0000000
--- a/wpiutil/src/main/native/include/wpi/UDPClient.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UDPCLIENT_H_
-#define WPIUTIL_WPI_UDPCLIENT_H_
-
-#include <string>
-#include <string_view>
-
-#include "wpi/SmallVector.h"
-#include "wpi/mutex.h"
-#include "wpi/span.h"
-
-namespace wpi {
-
-class Logger;
-
-class UDPClient {
-  int m_lsd;
-  int m_port;
-  std::string m_address;
-  Logger& m_logger;
-
- public:
-  explicit UDPClient(Logger& logger);
-  UDPClient(std::string_view address, Logger& logger);
-  UDPClient(const UDPClient& other) = delete;
-  UDPClient(UDPClient&& other);
-  ~UDPClient();
-
-  UDPClient& operator=(const UDPClient& other) = delete;
-  UDPClient& operator=(UDPClient&& other);
-
-  int start();
-  int start(int port);
-  void shutdown();
-  // The passed in address MUST be a resolved IP address.
-  int send(span<const uint8_t> data, std::string_view server, int port);
-  int send(std::string_view data, std::string_view server, int port);
-  int receive(uint8_t* data_received, int receive_len);
-  int receive(uint8_t* data_received, int receive_len,
-              SmallVectorImpl<char>* addr_received, int* port_received);
-  int set_timeout(double timeout);
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_UDPCLIENT_H_
diff --git a/wpiutil/src/main/native/include/wpi/UrlParser.h b/wpiutil/src/main/native/include/wpi/UrlParser.h
deleted file mode 100644
index 1932c3e..0000000
--- a/wpiutil/src/main/native/include/wpi/UrlParser.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_URLPARSER_H_
-#define WPIUTIL_WPI_URLPARSER_H_
-
-#include <string_view>
-
-#include "wpi/StringExtras.h"
-#include "wpi/http_parser.h"
-
-namespace wpi {
-
-/**
- * Parses a URL into its constiuent components.
- * `schema://userinfo@host:port/the/path?query#fragment`
- */
-class UrlParser {
- public:
-  /**
-   * Parse a URL.
-   * @param in input
-   * @param isConnect
-   */
-  UrlParser(std::string_view in, bool isConnect) {
-    m_data = in;
-    http_parser_url_init(&m_url);
-    m_error = http_parser_parse_url(in.data(), in.size(), isConnect, &m_url);
-  }
-
-  /**
-   * Determine if the URL is valid (e.g. the parse was successful).
-   */
-  bool IsValid() const { return !m_error; }
-
-  bool HasSchema() const { return (m_url.field_set & (1 << UF_SCHEMA)) != 0; }
-
-  bool HasHost() const { return (m_url.field_set & (1 << UF_HOST)) != 0; }
-
-  bool HasPort() const { return (m_url.field_set & (1 << UF_PORT)) != 0; }
-
-  bool HasPath() const { return (m_url.field_set & (1 << UF_PATH)) != 0; }
-
-  bool HasQuery() const { return (m_url.field_set & (1 << UF_QUERY)) != 0; }
-
-  bool HasFragment() const {
-    return (m_url.field_set & (1 << UF_FRAGMENT)) != 0;
-  }
-
-  bool HasUserInfo() const {
-    return (m_url.field_set & (1 << UF_USERINFO)) != 0;
-  }
-
-  std::string_view GetSchema() const {
-    return wpi::substr(m_data, m_url.field_data[UF_SCHEMA].off,
-                       m_url.field_data[UF_SCHEMA].len);
-  }
-
-  std::string_view GetHost() const {
-    return wpi::substr(m_data, m_url.field_data[UF_HOST].off,
-                       m_url.field_data[UF_HOST].len);
-  }
-
-  unsigned int GetPort() const { return m_url.port; }
-
-  std::string_view GetPath() const {
-    return wpi::substr(m_data, m_url.field_data[UF_PATH].off,
-                       m_url.field_data[UF_PATH].len);
-  }
-
-  std::string_view GetQuery() const {
-    return wpi::substr(m_data, m_url.field_data[UF_QUERY].off,
-                       m_url.field_data[UF_QUERY].len);
-  }
-
-  std::string_view GetFragment() const {
-    return wpi::substr(m_data, m_url.field_data[UF_FRAGMENT].off,
-                       m_url.field_data[UF_FRAGMENT].len);
-  }
-
-  std::string_view GetUserInfo() const {
-    return wpi::substr(m_data, m_url.field_data[UF_USERINFO].off,
-                       m_url.field_data[UF_USERINFO].len);
-  }
-
- private:
-  bool m_error;
-  std::string_view m_data;
-  http_parser_url m_url;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_URLPARSER_H_
diff --git a/wpiutil/src/main/native/include/wpi/WebSocket.h b/wpiutil/src/main/native/include/wpi/WebSocket.h
deleted file mode 100644
index fc2ae4a..0000000
--- a/wpiutil/src/main/native/include/wpi/WebSocket.h
+++ /dev/null
@@ -1,477 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_WEBSOCKET_H_
-#define WPIUTIL_WPI_WEBSOCKET_H_
-
-#include <stdint.h>
-
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/SmallVector.h"
-#include "wpi/span.h"
-#include "wpi/uv/Buffer.h"
-#include "wpi/uv/Error.h"
-#include "wpi/uv/Timer.h"
-
-namespace wpi {
-
-namespace uv {
-class Stream;
-}  // namespace uv
-
-/**
- * RFC 6455 compliant WebSocket client and server implementation.
- */
-class WebSocket : public std::enable_shared_from_this<WebSocket> {
-  struct private_init {};
-
-  static constexpr uint8_t kOpCont = 0x00;
-  static constexpr uint8_t kOpText = 0x01;
-  static constexpr uint8_t kOpBinary = 0x02;
-  static constexpr uint8_t kOpClose = 0x08;
-  static constexpr uint8_t kOpPing = 0x09;
-  static constexpr uint8_t kOpPong = 0x0A;
-  static constexpr uint8_t kOpMask = 0x0F;
-  static constexpr uint8_t kFlagFin = 0x80;
-  static constexpr uint8_t kFlagMasking = 0x80;
-  static constexpr uint8_t kLenMask = 0x7f;
-
- public:
-  WebSocket(uv::Stream& stream, bool server, const private_init&);
-  WebSocket(const WebSocket&) = delete;
-  WebSocket(WebSocket&&) = delete;
-  WebSocket& operator=(const WebSocket&) = delete;
-  WebSocket& operator=(WebSocket&&) = delete;
-  ~WebSocket();
-
-  /**
-   * Connection states.
-   */
-  enum State {
-    /** The connection is not yet open. */
-    CONNECTING = 0,
-    /** The connection is open and ready to communicate. */
-    OPEN,
-    /** The connection is in the process of closing. */
-    CLOSING,
-    /** The connection failed. */
-    FAILED,
-    /** The connection is closed. */
-    CLOSED
-  };
-
-  /**
-   * Client connection options.
-   */
-  struct ClientOptions {
-    ClientOptions() : handshakeTimeout{(uv::Timer::Time::max)()} {}
-
-    /** Timeout for the handshake request. */
-    uv::Timer::Time handshakeTimeout;  // NOLINT
-
-    /** Additional headers to include in handshake. */
-    span<const std::pair<std::string_view, std::string_view>> extraHeaders;
-  };
-
-  /**
-   * Starts a client connection by performing the initial client handshake.
-   * An open event is emitted when the handshake completes.
-   * This sets the stream user data to the websocket.
-   * @param stream Connection stream
-   * @param uri The Request-URI to send
-   * @param host The host or host:port to send
-   * @param protocols The list of subprotocols
-   * @param options Handshake options
-   */
-  static std::shared_ptr<WebSocket> CreateClient(
-      uv::Stream& stream, std::string_view uri, std::string_view host,
-      span<const std::string_view> protocols = {},
-      const ClientOptions& options = {});
-
-  /**
-   * Starts a client connection by performing the initial client handshake.
-   * An open event is emitted when the handshake completes.
-   * This sets the stream user data to the websocket.
-   * @param stream Connection stream
-   * @param uri The Request-URI to send
-   * @param host The host or host:port to send
-   * @param protocols The list of subprotocols
-   * @param options Handshake options
-   */
-  static std::shared_ptr<WebSocket> CreateClient(
-      uv::Stream& stream, std::string_view uri, std::string_view host,
-      std::initializer_list<std::string_view> protocols,
-      const ClientOptions& options = {}) {
-    return CreateClient(stream, uri, host, {protocols.begin(), protocols.end()},
-                        options);
-  }
-
-  /**
-   * Starts a server connection by performing the initial server side handshake.
-   * This should be called after the HTTP headers have been received.
-   * An open event is emitted when the handshake completes.
-   * This sets the stream user data to the websocket.
-   * @param stream Connection stream
-   * @param key The value of the Sec-WebSocket-Key header field in the client
-   *            request
-   * @param version The value of the Sec-WebSocket-Version header field in the
-   *                client request
-   * @param protocol The subprotocol to send to the client (in the
-   *                 Sec-WebSocket-Protocol header field).
-   */
-  static std::shared_ptr<WebSocket> CreateServer(
-      uv::Stream& stream, std::string_view key, std::string_view version,
-      std::string_view protocol = {});
-
-  /**
-   * Get connection state.
-   */
-  State GetState() const { return m_state; }
-
-  /**
-   * Return if the connection is open.  Messages can only be sent on open
-   * connections.
-   */
-  bool IsOpen() const { return m_state == OPEN; }
-
-  /**
-   * Get the underlying stream.
-   */
-  uv::Stream& GetStream() const { return m_stream; }
-
-  /**
-   * Get the selected sub-protocol.  Only valid in or after the open() event.
-   */
-  std::string_view GetProtocol() const { return m_protocol; }
-
-  /**
-   * Set the maximum message size.  Default is 128 KB.  If configured to combine
-   * fragments this maximum applies to the entire message (all combined
-   * fragments).
-   * @param size Maximum message size in bytes
-   */
-  void SetMaxMessageSize(size_t size) { m_maxMessageSize = size; }
-
-  /**
-   * Set whether or not fragmented frames should be combined.  Default is to
-   * combine.  If fragmented frames are combined, the text and binary callbacks
-   * will always have the second parameter (fin) set to true.
-   * @param combine True if fragmented frames should be combined.
-   */
-  void SetCombineFragments(bool combine) { m_combineFragments = combine; }
-
-  /**
-   * Initiate a closing handshake.
-   * @param code A numeric status code (defaults to 1005, no status code)
-   * @param reason A human-readable string explaining why the connection is
-   *               closing (optional).
-   */
-  void Close(uint16_t code = 1005, std::string_view reason = {});
-
-  /**
-   * Send a text message.
-   * @param data UTF-8 encoded data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendText(span<const uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpText, data, std::move(callback));
-  }
-
-  /**
-   * Send a text message.
-   * @param data UTF-8 encoded data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendText(std::initializer_list<uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendText({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Send a binary message.
-   * @param data Data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendBinary(span<const uv::Buffer> data,
-                  std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpBinary, data, std::move(callback));
-  }
-
-  /**
-   * Send a binary message.
-   * @param data Data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendBinary(std::initializer_list<uv::Buffer> data,
-                  std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendBinary({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Send a text message fragment.  This must be followed by one or more
-   * SendFragment() calls, where the last one has fin=True, to complete the
-   * message.
-   * @param data UTF-8 encoded data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendTextFragment(
-      span<const uv::Buffer> data,
-      std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpText, data, std::move(callback));
-  }
-
-  /**
-   * Send a text message fragment.  This must be followed by one or more
-   * SendFragment() calls, where the last one has fin=True, to complete the
-   * message.
-   * @param data UTF-8 encoded data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendTextFragment(
-      std::initializer_list<uv::Buffer> data,
-      std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendTextFragment({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Send a text message fragment.  This must be followed by one or more
-   * SendFragment() calls, where the last one has fin=True, to complete the
-   * message.
-   * @param data Data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendBinaryFragment(
-      span<const uv::Buffer> data,
-      std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpBinary, data, std::move(callback));
-  }
-
-  /**
-   * Send a text message fragment.  This must be followed by one or more
-   * SendFragment() calls, where the last one has fin=True, to complete the
-   * message.
-   * @param data Data to send
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendBinaryFragment(
-      std::initializer_list<uv::Buffer> data,
-      std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendBinaryFragment({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Send a continuation frame.  This is used to send additional parts of a
-   * message started with SendTextFragment() or SendBinaryFragment().
-   * @param data Data to send
-   * @param fin Set to true if this is the final fragment of the message
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendFragment(span<const uv::Buffer> data, bool fin,
-                    std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kOpCont | (fin ? kFlagFin : 0), data, std::move(callback));
-  }
-
-  /**
-   * Send a continuation frame.  This is used to send additional parts of a
-   * message started with SendTextFragment() or SendBinaryFragment().
-   * @param data Data to send
-   * @param fin Set to true if this is the final fragment of the message
-   * @param callback Callback which is invoked when the write completes.
-   */
-  void SendFragment(std::initializer_list<uv::Buffer> data, bool fin,
-                    std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendFragment({data.begin(), data.end()}, fin, std::move(callback));
-  }
-
-  /**
-   * Send a ping frame with no data.
-   * @param callback Optional callback which is invoked when the ping frame
-   *                 write completes.
-   */
-  void SendPing(std::function<void(uv::Error)> callback = nullptr) {
-    SendPing({}, [f = std::move(callback)](auto bufs, uv::Error err) {
-      if (f) {
-        f(err);
-      }
-    });
-  }
-
-  /**
-   * Send a ping frame.
-   * @param data Data to send in the ping frame
-   * @param callback Callback which is invoked when the ping frame
-   *                 write completes.
-   */
-  void SendPing(span<const uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpPing, data, std::move(callback));
-  }
-
-  /**
-   * Send a ping frame.
-   * @param data Data to send in the ping frame
-   * @param callback Callback which is invoked when the ping frame
-   *                 write completes.
-   */
-  void SendPing(std::initializer_list<uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendPing({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Send a pong frame with no data.
-   * @param callback Optional callback which is invoked when the pong frame
-   *                 write completes.
-   */
-  void SendPong(std::function<void(uv::Error)> callback = nullptr) {
-    SendPong({}, [f = std::move(callback)](auto bufs, uv::Error err) {
-      if (f) {
-        f(err);
-      }
-    });
-  }
-
-  /**
-   * Send a pong frame.
-   * @param data Data to send in the pong frame
-   * @param callback Callback which is invoked when the pong frame
-   *                 write completes.
-   */
-  void SendPong(span<const uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    Send(kFlagFin | kOpPong, data, std::move(callback));
-  }
-
-  /**
-   * Send a pong frame.
-   * @param data Data to send in the pong frame
-   * @param callback Callback which is invoked when the pong frame
-   *                 write completes.
-   */
-  void SendPong(std::initializer_list<uv::Buffer> data,
-                std::function<void(span<uv::Buffer>, uv::Error)> callback) {
-    SendPong({data.begin(), data.end()}, std::move(callback));
-  }
-
-  /**
-   * Fail the connection.
-   */
-  void Fail(uint16_t code = 1002, std::string_view reason = "protocol error");
-
-  /**
-   * Forcibly close the connection.
-   */
-  void Terminate(uint16_t code = 1006, std::string_view reason = "terminated");
-
-  /**
-   * Gets user-defined data.
-   * @return User-defined data if any, nullptr otherwise.
-   */
-  template <typename T = void>
-  std::shared_ptr<T> GetData() const {
-    return std::static_pointer_cast<T>(m_data);
-  }
-
-  /**
-   * Sets user-defined data.
-   * @param data User-defined arbitrary data.
-   */
-  void SetData(std::shared_ptr<void> data) { m_data = std::move(data); }
-
-  /**
-   * Shuts down and closes the underlying stream.
-   */
-  void Shutdown();
-
-  /**
-   * Open event.  Emitted when the connection is open and ready to communicate.
-   * The parameter is the selected subprotocol.
-   */
-  sig::Signal<std::string_view> open;
-
-  /**
-   * Close event.  Emitted when the connection is closed.  The first parameter
-   * is a numeric value indicating the status code explaining why the connection
-   * has been closed.  The second parameter is a human-readable string
-   * explaining the reason why the connection has been closed.
-   */
-  sig::Signal<uint16_t, std::string_view> closed;
-
-  /**
-   * Text message event.  Emitted when a text message is received.
-   * The first parameter is the data, the second parameter is true if the
-   * data is the last fragment of the message.
-   */
-  sig::Signal<std::string_view, bool> text;
-
-  /**
-   * Binary message event.  Emitted when a binary message is received.
-   * The first parameter is the data, the second parameter is true if the
-   * data is the last fragment of the message.
-   */
-  sig::Signal<span<const uint8_t>, bool> binary;
-
-  /**
-   * Ping event.  Emitted when a ping message is received.
-   */
-  sig::Signal<span<const uint8_t>> ping;
-
-  /**
-   * Pong event.  Emitted when a pong message is received.
-   */
-  sig::Signal<span<const uint8_t>> pong;
-
- private:
-  // user data
-  std::shared_ptr<void> m_data;
-
-  // constructor parameters
-  uv::Stream& m_stream;
-  bool m_server;
-
-  // subprotocol, set via constructor (server) or handshake (client)
-  std::string m_protocol;
-
-  // user-settable configuration
-  size_t m_maxMessageSize = 128 * 1024;
-  bool m_combineFragments = true;
-
-  // operating state
-  State m_state = CONNECTING;
-
-  // incoming message buffers/state
-  SmallVector<uint8_t, 14> m_header;
-  size_t m_headerSize = 0;
-  SmallVector<uint8_t, 1024> m_payload;
-  size_t m_frameStart = 0;
-  uint64_t m_frameSize = UINT64_MAX;
-  uint8_t m_fragmentOpcode = 0;
-
-  // temporary data used only during client handshake
-  class ClientHandshakeData;
-  std::unique_ptr<ClientHandshakeData> m_clientHandshake;
-
-  void StartClient(std::string_view uri, std::string_view host,
-                   span<const std::string_view> protocols,
-                   const ClientOptions& options);
-  void StartServer(std::string_view key, std::string_view version,
-                   std::string_view protocol);
-  void SendClose(uint16_t code, std::string_view reason);
-  void SetClosed(uint16_t code, std::string_view reason, bool failed = false);
-  void HandleIncoming(uv::Buffer& buf, size_t size);
-  void Send(uint8_t opcode, span<const uv::Buffer> data,
-            std::function<void(span<uv::Buffer>, uv::Error)> callback);
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_WEBSOCKET_H_
diff --git a/wpiutil/src/main/native/include/wpi/WebSocketServer.h b/wpiutil/src/main/native/include/wpi/WebSocketServer.h
deleted file mode 100644
index 1f76d16..0000000
--- a/wpiutil/src/main/native/include/wpi/WebSocketServer.h
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_WEBSOCKETSERVER_H_
-#define WPIUTIL_WPI_WEBSOCKETSERVER_H_
-
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <utility>
-
-#include "wpi/HttpParser.h"
-#include "wpi/Signal.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/WebSocket.h"
-#include "wpi/span.h"
-
-namespace wpi {
-
-namespace uv {
-class Stream;
-}  // namespace uv
-
-/**
- * WebSocket HTTP server helper.  Handles websocket-specific headers.  User
- * must provide the HttpParser.
- */
-class WebSocketServerHelper {
- public:
-  /**
-   * Constructor.
-   * @param req HttpParser for request
-   */
-  explicit WebSocketServerHelper(HttpParser& req);
-
-  /**
-   * Get whether or not this was a websocket upgrade.
-   * Only valid during and after the upgrade event.
-   */
-  bool IsWebsocket() const { return m_websocket; }
-
-  /**
-   * Try to find a match to the list of sub-protocols provided by the client.
-   * The list is priority ordered, so the first match wins.
-   * Only valid during and after the upgrade event.
-   * @param protocols Acceptable protocols
-   * @return Pair; first item is true if a match was made, false if not.
-   *         Second item is the matched protocol if a match was made, otherwise
-   *         is empty.
-   */
-  std::pair<bool, std::string_view> MatchProtocol(
-      span<const std::string_view> protocols);
-
-  /**
-   * Try to find a match to the list of sub-protocols provided by the client.
-   * The list is priority ordered, so the first match wins.
-   * Only valid during and after the upgrade event.
-   * @param protocols Acceptable protocols
-   * @return Pair; first item is true if a match was made, false if not.
-   *         Second item is the matched protocol if a match was made, otherwise
-   *         is empty.
-   */
-  std::pair<bool, std::string_view> MatchProtocol(
-      std::initializer_list<std::string_view> protocols) {
-    return MatchProtocol({protocols.begin(), protocols.end()});
-  }
-
-  /**
-   * Accept the upgrade.  Disconnect other readers (such as the HttpParser
-   * reader) before calling this.  See also WebSocket::CreateServer().
-   * @param stream Connection stream
-   * @param protocol The subprotocol to send to the client
-   */
-  std::shared_ptr<WebSocket> Accept(uv::Stream& stream,
-                                    std::string_view protocol = {}) {
-    return WebSocket::CreateServer(stream, m_key, m_version, protocol);
-  }
-
-  bool IsUpgrade() const { return m_gotHost && m_websocket; }
-
-  /**
-   * Upgrade event.  Call Accept() to accept the upgrade.
-   */
-  sig::Signal<> upgrade;
-
- private:
-  bool m_gotHost = false;
-  bool m_websocket = false;
-  SmallVector<std::string, 2> m_protocols;
-  SmallString<64> m_key;
-  SmallString<16> m_version;
-};
-
-/**
- * Dedicated WebSocket server.
- */
-class WebSocketServer : public std::enable_shared_from_this<WebSocketServer> {
-  struct private_init {};
-
- public:
-  /**
-   * Server options.
-   */
-  struct ServerOptions {
-    /**
-     * Checker for URL.  Return true if URL should be accepted.  By default all
-     * URLs are accepted.
-     */
-    std::function<bool(std::string_view)> checkUrl;
-
-    /**
-     * Checker for Host header.  Return true if Host should be accepted.  By
-     * default all hosts are accepted.
-     */
-    std::function<bool(std::string_view)> checkHost;
-  };
-
-  /**
-   * Private constructor.
-   */
-  WebSocketServer(uv::Stream& stream, span<const std::string_view> protocols,
-                  ServerOptions options, const private_init&);
-
-  /**
-   * Starts a dedicated WebSocket server on the provided connection.  The
-   * connection should be an accepted client stream.
-   * This also sets the stream user data to the socket server.
-   * A connected event is emitted when the connection is opened.
-   * @param stream Connection stream
-   * @param protocols Acceptable subprotocols
-   * @param options Handshake options
-   */
-  static std::shared_ptr<WebSocketServer> Create(
-      uv::Stream& stream, span<const std::string_view> protocols = {},
-      const ServerOptions& options = {});
-
-  /**
-   * Starts a dedicated WebSocket server on the provided connection.  The
-   * connection should be an accepted client stream.
-   * This also sets the stream user data to the socket server.
-   * A connected event is emitted when the connection is opened.
-   * @param stream Connection stream
-   * @param protocols Acceptable subprotocols
-   * @param options Handshake options
-   */
-  static std::shared_ptr<WebSocketServer> Create(
-      uv::Stream& stream, std::initializer_list<std::string_view> protocols,
-      const ServerOptions& options = {}) {
-    return Create(stream, {protocols.begin(), protocols.end()}, options);
-  }
-
-  /**
-   * Connected event.  First parameter is the URL, second is the websocket.
-   */
-  sig::Signal<std::string_view, WebSocket&> connected;
-
- private:
-  uv::Stream& m_stream;
-  HttpParser m_req{HttpParser::kRequest};
-  WebSocketServerHelper m_helper;
-  SmallVector<std::string, 2> m_protocols;
-  ServerOptions m_options;
-  bool m_aborted = false;
-  sig::ScopedConnection m_dataConn;
-  sig::ScopedConnection m_errorConn;
-  sig::ScopedConnection m_endConn;
-
-  void Abort(uint16_t code, std::string_view reason);
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_WEBSOCKETSERVER_H_
diff --git a/wpiutil/src/main/native/include/wpi/WorkerThread.h b/wpiutil/src/main/native/include/wpi/WorkerThread.h
deleted file mode 100644
index 6c8852e..0000000
--- a/wpiutil/src/main/native/include/wpi/WorkerThread.h
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_WORKERTHREAD_H_
-#define WPIUTIL_WPI_WORKERTHREAD_H_
-
-#include <functional>
-#include <memory>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#include "wpi/SafeThread.h"
-#include "wpi/future.h"
-#include "wpi/uv/Async.h"
-
-namespace wpi {
-
-namespace detail {
-
-template <typename R>
-struct WorkerThreadAsync {
-  using AfterWorkFunction = std::function<void(R)>;
-
-  ~WorkerThreadAsync() { UnsetLoop(); }
-
-  void SetLoop(uv::Loop& loop) {
-    auto async = uv::Async<AfterWorkFunction, R>::Create(loop);
-    async->wakeup.connect(
-        [](AfterWorkFunction func, R result) { func(result); });
-    m_async = async;
-  }
-
-  void UnsetLoop() {
-    if (auto async = m_async.lock()) {
-      async->Close();
-      m_async.reset();
-    }
-  }
-
-  std::weak_ptr<uv::Async<AfterWorkFunction, R>> m_async;
-};
-
-template <>
-struct WorkerThreadAsync<void> {
-  using AfterWorkFunction = std::function<void()>;
-
-  ~WorkerThreadAsync() { RemoveLoop(); }
-
-  void SetLoop(uv::Loop& loop) {
-    auto async = uv::Async<AfterWorkFunction>::Create(loop);
-    async->wakeup.connect([](AfterWorkFunction func) { func(); });
-    m_async = async;
-  }
-
-  void RemoveLoop() {
-    if (auto async = m_async.lock()) {
-      async->Close();
-      m_async.reset();
-    }
-  }
-
-  std::weak_ptr<uv::Async<AfterWorkFunction>> m_async;
-};
-
-template <typename R, typename... T>
-struct WorkerThreadRequest {
-  using WorkFunction = std::function<R(T...)>;
-  using AfterWorkFunction = typename WorkerThreadAsync<R>::AfterWorkFunction;
-
-  WorkerThreadRequest() = default;
-  WorkerThreadRequest(uint64_t promiseId_, WorkFunction work_,
-                      std::tuple<T...> params_)
-      : promiseId(promiseId_),
-        work(std::move(work_)),
-        params(std::move(params_)) {}
-  WorkerThreadRequest(WorkFunction work_, AfterWorkFunction afterWork_,
-                      std::tuple<T...> params_)
-      : promiseId(0),
-        work(std::move(work_)),
-        afterWork(std::move(afterWork_)),
-        params(std::move(params_)) {}
-
-  uint64_t promiseId;
-  WorkFunction work;
-  AfterWorkFunction afterWork;
-  std::tuple<T...> params;
-};
-
-template <typename R, typename... T>
-class WorkerThreadThread : public SafeThread {
- public:
-  using Request = WorkerThreadRequest<R, T...>;
-
-  void Main() override;
-
-  std::vector<Request> m_requests;
-  PromiseFactory<R> m_promises;
-  detail::WorkerThreadAsync<R> m_async;
-};
-
-template <typename R, typename... T>
-void RunWorkerThreadRequest(WorkerThreadThread<R, T...>& thr,
-                            WorkerThreadRequest<R, T...>& req) {
-  R result = std::apply(req.work, std::move(req.params));
-  if (req.afterWork) {
-    if (auto async = thr.m_async.m_async.lock()) {
-      async->Send(std::move(req.afterWork), std::move(result));
-    }
-  } else {
-    thr.m_promises.SetValue(req.promiseId, std::move(result));
-  }
-}
-
-template <typename... T>
-void RunWorkerThreadRequest(WorkerThreadThread<void, T...>& thr,
-                            WorkerThreadRequest<void, T...>& req) {
-  std::apply(req.work, req.params);
-  if (req.afterWork) {
-    if (auto async = thr.m_async.m_async.lock()) {
-      async->Send(std::move(req.afterWork));
-    }
-  } else {
-    thr.m_promises.SetValue(req.promiseId);
-  }
-}
-
-template <typename R, typename... T>
-void WorkerThreadThread<R, T...>::Main() {
-  std::vector<Request> requests;
-  while (m_active) {
-    std::unique_lock lock(m_mutex);
-    m_cond.wait(lock, [&] { return !m_active || !m_requests.empty(); });
-    if (!m_active) {
-      break;
-    }
-
-    // don't want to hold the lock while executing the callbacks
-    requests.swap(m_requests);
-    lock.unlock();
-
-    for (auto&& req : requests) {
-      if (!m_active) {
-        break;  // requests may be long-running
-      }
-      RunWorkerThreadRequest(*this, req);
-    }
-    requests.clear();
-    m_promises.Notify();
-  }
-}
-
-}  // namespace detail
-
-template <typename T>
-class WorkerThread;
-
-template <typename R, typename... T>
-class WorkerThread<R(T...)> final {
-  using Thread = detail::WorkerThreadThread<R, T...>;
-
- public:
-  using WorkFunction = std::function<R(T...)>;
-  using AfterWorkFunction =
-      typename detail::WorkerThreadAsync<R>::AfterWorkFunction;
-
-  WorkerThread() { m_owner.Start(); }
-
-  /**
-   * Set the loop.  This must be called from the loop thread.
-   * Subsequent calls to QueueWorkThen will run afterWork on the provided
-   * loop (via an async handle).
-   *
-   * @param loop the loop to use for running afterWork routines
-   */
-  void SetLoop(uv::Loop& loop) {
-    if (auto thr = m_owner.GetThread()) {
-      thr->m_async.SetLoop(loop);
-    }
-  }
-
-  /**
-   * Set the loop.  This must be called from the loop thread.
-   * Subsequent calls to QueueWorkThen will run afterWork on the provided
-   * loop (via an async handle).
-   *
-   * @param loop the loop to use for running afterWork routines
-   */
-  void SetLoop(std::shared_ptr<uv::Loop> loop) { SetLoop(*loop); }
-
-  /**
-   * Unset the loop.  This must be called from the loop thread.
-   * Subsequent calls to QueueWorkThen will no longer run afterWork.
-   */
-  void UnsetLoop() {
-    if (auto thr = m_owner.GetThread()) {
-      thr->m_async.UnsetLoop();
-    }
-  }
-
-  /**
-   * Get the handle used by QueueWorkThen() to run afterWork.
-   * This handle is set by SetLoop().
-   * Calling Close() on this handle is the same as calling UnsetLoop().
-   *
-   * @return The handle (if nullptr, no handle is set)
-   */
-  std::shared_ptr<uv::Handle> GetHandle() const {
-    if (auto thr = m_owner.GetThread()) {
-      return thr->m_async.m_async.lock();
-    } else {
-      return nullptr;
-    }
-  }
-
-  /**
-   * Wakeup the worker thread, call the work function, and return a future for
-   * the result.
-   *
-   * It’s safe to call this function from any thread.
-   * The work function will be called on the worker thread.
-   *
-   * The future will return a default-constructed result if this class is
-   * destroyed while waiting for a result.
-   *
-   * @param work Work function (called on worker thread)
-   * @param u Arguments to work function
-   */
-  template <typename... U>
-  future<R> QueueWork(WorkFunction work, U&&... u) {
-    if (auto thr = m_owner.GetThread()) {
-      // create the future
-      uint64_t req = thr->m_promises.CreateRequest();
-
-      // add the parameters to the input queue
-      thr->m_requests.emplace_back(
-          req, std::move(work), std::forward_as_tuple(std::forward<U>(u)...));
-
-      // signal the thread
-      thr->m_cond.notify_one();
-
-      // return future
-      return thr->m_promises.CreateFuture(req);
-    }
-
-    // XXX: is this the right thing to do?
-    return future<R>();
-  }
-
-  /**
-   * Wakeup the worker thread, call the work function, and call the afterWork
-   * function with the result on the loop set by SetLoop().
-   *
-   * It’s safe to call this function from any thread.
-   * The work function will be called on the worker thread, and the afterWork
-   * function will be called on the loop thread.
-   *
-   * SetLoop() must be called prior to calling this function for afterWork to
-   * be called.
-   *
-   * @param work Work function (called on worker thread)
-   * @param afterWork After work function (called on loop thread)
-   * @param u Arguments to work function
-   */
-  template <typename... U>
-  void QueueWorkThen(WorkFunction work, AfterWorkFunction afterWork, U&&... u) {
-    if (auto thr = m_owner.GetThread()) {
-      // add the parameters to the input queue
-      thr->m_requests.emplace_back(
-          std::move(work), std::move(afterWork),
-          std::forward_as_tuple(std::forward<U>(u)...));
-
-      // signal the thread
-      thr->m_cond.notify_one();
-    }
-  }
-
- private:
-  SafeThreadOwner<Thread> m_owner;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_WORKERTHREAD_H_
diff --git a/wpiutil/src/main/native/include/wpi/array.h b/wpiutil/src/main/native/include/wpi/array.h
index f2604ec..cfbb7b0 100644
--- a/wpiutil/src/main/native/include/wpi/array.h
+++ b/wpiutil/src/main/native/include/wpi/array.h
@@ -24,33 +24,33 @@
 template <typename T, size_t N>
 class array : public std::array<T, N> {
  public:
-  explicit array(empty_array_t) {}
+  constexpr explicit array(empty_array_t) {}
 
   template <typename... Ts>
-  array(T arg, Ts&&... args)  // NOLINT
+  constexpr array(T arg, Ts&&... args)  // NOLINT
       : std::array<T, N>{std::forward<T>(arg), std::forward<Ts>(args)...} {
     static_assert(1 + sizeof...(args) == N, "Dimension mismatch");
   }
 
-  array(const array<T, N>&) = default;
-  array& operator=(const array<T, N>&) = default;
-  array(array<T, N>&&) = default;
-  array& operator=(array<T, N>&&) = default;
+  constexpr array(const array<T, N>&) = default;
+  constexpr array& operator=(const array<T, N>&) = default;
+  constexpr array(array<T, N>&&) = default;
+  constexpr array& operator=(array<T, N>&&) = default;
 
-  array(const std::array<T, N>& rhs) {  // NOLINT
+  constexpr array(const std::array<T, N>& rhs) {  // NOLINT
     *static_cast<std::array<T, N>*>(this) = rhs;
   }
 
-  array& operator=(const std::array<T, N>& rhs) {
+  constexpr array& operator=(const std::array<T, N>& rhs) {
     *static_cast<std::array<T, N>*>(this) = rhs;
     return *this;
   }
 
-  array(std::array<T, N>&& rhs) {  // NOLINT
+  constexpr array(std::array<T, N>&& rhs) {  // NOLINT
     *static_cast<std::array<T, N>*>(this) = rhs;
   }
 
-  array& operator=(std::array<T, N>&& rhs) {
+  constexpr array& operator=(std::array<T, N>&& rhs) {
     *static_cast<std::array<T, N>*>(this) = rhs;
     return *this;
   }
diff --git a/wpiutil/src/main/native/include/wpi/circular_buffer.h b/wpiutil/src/main/native/include/wpi/circular_buffer.h
index 40913f9..c54e2f5 100644
--- a/wpiutil/src/main/native/include/wpi/circular_buffer.h
+++ b/wpiutil/src/main/native/include/wpi/circular_buffer.h
@@ -43,10 +43,7 @@
       ++(*this);
       return retval;
     }
-    bool operator==(const iterator& other) const {
-      return m_buffer == other.m_buffer && m_index == other.m_index;
-    }
-    bool operator!=(const iterator& other) const { return !(*this == other); }
+    bool operator==(const iterator&) const = default;
     reference operator*() { return (*m_buffer)[m_index]; }
 
    private:
@@ -74,12 +71,7 @@
       ++(*this);
       return retval;
     }
-    bool operator==(const const_iterator& other) const {
-      return m_buffer == other.m_buffer && m_index == other.m_index;
-    }
-    bool operator!=(const const_iterator& other) const {
-      return !(*this == other);
-    }
+    bool operator==(const const_iterator&) const = default;
     const_reference operator*() const { return (*m_buffer)[m_index]; }
 
    private:
diff --git a/wpiutil/src/main/native/include/wpi/deprecated.h b/wpiutil/src/main/native/include/wpi/deprecated.h
index 6e6a3bf..c5b4af2 100644
--- a/wpiutil/src/main/native/include/wpi/deprecated.h
+++ b/wpiutil/src/main/native/include/wpi/deprecated.h
@@ -9,4 +9,23 @@
 #define WPI_DEPRECATED(msg) [[deprecated(msg)]]
 #endif
 
+#ifndef WPI_IGNORE_DEPRECATED
+#ifdef __GNUC__
+#define WPI_IGNORE_DEPRECATED    \
+  _Pragma("GCC diagnostic push") \
+      _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif defined(_WIN32)
+#define WPI_IGNORE_DEPRECATED _Pragma("warning(disable : 4996)")
+#endif
+
+#endif
+
+#ifndef WPI_UNIGNORE_DEPRECATED
+#ifdef __GNUC__
+#define WPI_UNIGNORE_DEPRECATED _Pragma("GCC diagnostic pop")
+#elif defined(_WIN32)
+#define WPI_UNIGNORE_DEPRECATED _Pragma("warning(default : 4996)")
+#endif
+#endif
+
 #endif  // WPIUTIL_WPI_DEPRECATED_H_
diff --git a/wpiutil/src/main/native/include/wpi/fmt/raw_ostream.h b/wpiutil/src/main/native/include/wpi/fmt/raw_ostream.h
index 8779bfc..024e04c 100644
--- a/wpiutil/src/main/native/include/wpi/fmt/raw_ostream.h
+++ b/wpiutil/src/main/native/include/wpi/fmt/raw_ostream.h
@@ -22,7 +22,7 @@
  */
 template <typename S, typename... Args>
 void print(wpi::raw_ostream& os, const S& format_str, Args&&... args) {
-  vprint(os, format_str, fmt::make_args_checked<Args...>(format_str, args...));
+  vprint(os, format_str, fmt::make_format_args(args...));
 }
 
 FMT_END_NAMESPACE
diff --git a/wpiutil/src/main/native/include/wpi/fs.h b/wpiutil/src/main/native/include/wpi/fs.h
index fca8069..587a23c 100644
--- a/wpiutil/src/main/native/include/wpi/fs.h
+++ b/wpiutil/src/main/native/include/wpi/fs.h
@@ -40,7 +40,7 @@
 #ifndef GHC_USE_STD_FS
 // #define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
 #define GHC_FILESYSTEM_FWD
-#include "ghc/filesystem.hpp"
+#include "wpi/ghc/filesystem.hpp"
 namespace fs {
 using namespace ghc::filesystem;
 using ifstream = ghc::filesystem::ifstream;
diff --git a/wpiutil/src/main/native/include/wpi/future.h b/wpiutil/src/main/native/include/wpi/future.h
index 5cb4a8d..70dc60f 100644
--- a/wpiutil/src/main/native/include/wpi/future.h
+++ b/wpiutil/src/main/native/include/wpi/future.h
@@ -334,7 +334,7 @@
     }
   }
 
-  template <typename F, typename R = typename std::result_of<F && (T &&)>::type>
+  template <typename F, typename R = typename std::invoke_result_t<F&&, T&&>>
   future<R> then(F&& func) {
     return then(PromiseFactory<R>::GetInstance(), std::forward<F>(func));
   }
@@ -457,7 +457,7 @@
     }
   }
 
-  template <typename F, typename R = typename std::result_of<F && ()>::type>
+  template <typename F, typename R = typename std::invoke_result_t<F&&>>
   future<R> then(F&& func) {
     return then(PromiseFactory<R>::GetInstance(), std::forward<F>(func));
   }
diff --git a/wpiutil/src/main/native/include/wpi/hostname.h b/wpiutil/src/main/native/include/wpi/hostname.h
deleted file mode 100644
index bd93b4a..0000000
--- a/wpiutil/src/main/native/include/wpi/hostname.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_HOSTNAME_H_
-#define WPIUTIL_WPI_HOSTNAME_H_
-
-#include <string>
-#include <string_view>
-
-namespace wpi {
-template <typename T>
-class SmallVectorImpl;
-
-std::string GetHostname();
-std::string_view GetHostname(SmallVectorImpl<char>& name);
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_HOSTNAME_H_
diff --git a/wpiutil/src/main/native/include/wpi/http_parser.h b/wpiutil/src/main/native/include/wpi/http_parser.h
deleted file mode 100644
index 2189b8f..0000000
--- a/wpiutil/src/main/native/include/wpi/http_parser.h
+++ /dev/null
@@ -1,421 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-#ifndef wpi_http_parser_h
-#define wpi_http_parser_h
-
-/* Also update SONAME in the Makefile whenever you change these. */
-#define HTTP_PARSER_VERSION_MAJOR 2
-#define HTTP_PARSER_VERSION_MINOR 8
-#define HTTP_PARSER_VERSION_PATCH 1
-
-#include <stddef.h>
-#include <stdint.h>
-
-/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
- * faster
- */
-#ifndef HTTP_PARSER_STRICT
-# define HTTP_PARSER_STRICT 1
-#endif
-
-/* Maximium header size allowed. If the macro is not defined
- * before including this header then the default is used. To
- * change the maximum header size, define the macro in the build
- * environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
- * the effective limit on the size of the header, define the macro
- * to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff)
- */
-#ifndef HTTP_MAX_HEADER_SIZE
-# define HTTP_MAX_HEADER_SIZE (80*1024)
-#endif
-
-namespace wpi {
-
-struct http_parser;
-struct http_parser_settings;
-
-
-/* Callbacks should return non-zero to indicate an error. The parser will
- * then halt execution.
- *
- * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
- * returning '1' from on_headers_complete will tell the parser that it
- * should not expect a body. This is used when receiving a response to a
- * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
- * chunked' headers that indicate the presence of a body.
- *
- * Returning `2` from on_headers_complete will tell parser that it should not
- * expect neither a body nor any further responses on this connection. This is
- * useful for handling responses to a CONNECT request which may not contain
- * `Upgrade` or `Connection: upgrade` headers.
- *
- * http_data_cb does not return data chunks. It will be called arbitrarily
- * many times for each string. E.G. you might get 10 callbacks for "on_url"
- * each providing just a few characters more data.
- */
-typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
-typedef int (*http_cb) (http_parser*);
-
-
-/* Status Codes */
-#define HTTP_STATUS_MAP(XX)                                                 \
-  XX(100, CONTINUE,                        Continue)                        \
-  XX(101, SWITCHING_PROTOCOLS,             Switching Protocols)             \
-  XX(102, PROCESSING,                      Processing)                      \
-  XX(200, OK,                              OK)                              \
-  XX(201, CREATED,                         Created)                         \
-  XX(202, ACCEPTED,                        Accepted)                        \
-  XX(203, NON_AUTHORITATIVE_INFORMATION,   Non-Authoritative Information)   \
-  XX(204, NO_CONTENT,                      No Content)                      \
-  XX(205, RESET_CONTENT,                   Reset Content)                   \
-  XX(206, PARTIAL_CONTENT,                 Partial Content)                 \
-  XX(207, MULTI_STATUS,                    Multi-Status)                    \
-  XX(208, ALREADY_REPORTED,                Already Reported)                \
-  XX(226, IM_USED,                         IM Used)                         \
-  XX(300, MULTIPLE_CHOICES,                Multiple Choices)                \
-  XX(301, MOVED_PERMANENTLY,               Moved Permanently)               \
-  XX(302, FOUND,                           Found)                           \
-  XX(303, SEE_OTHER,                       See Other)                       \
-  XX(304, NOT_MODIFIED,                    Not Modified)                    \
-  XX(305, USE_PROXY,                       Use Proxy)                       \
-  XX(307, TEMPORARY_REDIRECT,              Temporary Redirect)              \
-  XX(308, PERMANENT_REDIRECT,              Permanent Redirect)              \
-  XX(400, BAD_REQUEST,                     Bad Request)                     \
-  XX(401, UNAUTHORIZED,                    Unauthorized)                    \
-  XX(402, PAYMENT_REQUIRED,                Payment Required)                \
-  XX(403, FORBIDDEN,                       Forbidden)                       \
-  XX(404, NOT_FOUND,                       Not Found)                       \
-  XX(405, METHOD_NOT_ALLOWED,              Method Not Allowed)              \
-  XX(406, NOT_ACCEPTABLE,                  Not Acceptable)                  \
-  XX(407, PROXY_AUTHENTICATION_REQUIRED,   Proxy Authentication Required)   \
-  XX(408, REQUEST_TIMEOUT,                 Request Timeout)                 \
-  XX(409, CONFLICT,                        Conflict)                        \
-  XX(410, GONE,                            Gone)                            \
-  XX(411, LENGTH_REQUIRED,                 Length Required)                 \
-  XX(412, PRECONDITION_FAILED,             Precondition Failed)             \
-  XX(413, PAYLOAD_TOO_LARGE,               Payload Too Large)               \
-  XX(414, URI_TOO_LONG,                    URI Too Long)                    \
-  XX(415, UNSUPPORTED_MEDIA_TYPE,          Unsupported Media Type)          \
-  XX(416, RANGE_NOT_SATISFIABLE,           Range Not Satisfiable)           \
-  XX(417, EXPECTATION_FAILED,              Expectation Failed)              \
-  XX(421, MISDIRECTED_REQUEST,             Misdirected Request)             \
-  XX(422, UNPROCESSABLE_ENTITY,            Unprocessable Entity)            \
-  XX(423, LOCKED,                          Locked)                          \
-  XX(424, FAILED_DEPENDENCY,               Failed Dependency)               \
-  XX(426, UPGRADE_REQUIRED,                Upgrade Required)                \
-  XX(428, PRECONDITION_REQUIRED,           Precondition Required)           \
-  XX(429, TOO_MANY_REQUESTS,               Too Many Requests)               \
-  XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, Request Header Fields Too Large) \
-  XX(451, UNAVAILABLE_FOR_LEGAL_REASONS,   Unavailable For Legal Reasons)   \
-  XX(500, INTERNAL_SERVER_ERROR,           Internal Server Error)           \
-  XX(501, NOT_IMPLEMENTED,                 Not Implemented)                 \
-  XX(502, BAD_GATEWAY,                     Bad Gateway)                     \
-  XX(503, SERVICE_UNAVAILABLE,             Service Unavailable)             \
-  XX(504, GATEWAY_TIMEOUT,                 Gateway Timeout)                 \
-  XX(505, HTTP_VERSION_NOT_SUPPORTED,      HTTP Version Not Supported)      \
-  XX(506, VARIANT_ALSO_NEGOTIATES,         Variant Also Negotiates)         \
-  XX(507, INSUFFICIENT_STORAGE,            Insufficient Storage)            \
-  XX(508, LOOP_DETECTED,                   Loop Detected)                   \
-  XX(510, NOT_EXTENDED,                    Not Extended)                    \
-  XX(511, NETWORK_AUTHENTICATION_REQUIRED, Network Authentication Required) \
-
-enum http_status
-  {
-#define XX(num, name, string) HTTP_STATUS_##name = num,
-  HTTP_STATUS_MAP(XX)
-#undef XX
-  };
-
-
-/* Request Methods */
-#define HTTP_METHOD_MAP(XX)         \
-  XX(0,  DELETE,      DELETE)       \
-  XX(1,  GET,         GET)          \
-  XX(2,  HEAD,        HEAD)         \
-  XX(3,  POST,        POST)         \
-  XX(4,  PUT,         PUT)          \
-  /* pathological */                \
-  XX(5,  CONNECT,     CONNECT)      \
-  XX(6,  OPTIONS,     OPTIONS)      \
-  XX(7,  TRACE,       TRACE)        \
-  /* WebDAV */                      \
-  XX(8,  COPY,        COPY)         \
-  XX(9,  LOCK,        LOCK)         \
-  XX(10, MKCOL,       MKCOL)        \
-  XX(11, MOVE,        MOVE)         \
-  XX(12, PROPFIND,    PROPFIND)     \
-  XX(13, PROPPATCH,   PROPPATCH)    \
-  XX(14, SEARCH,      SEARCH)       \
-  XX(15, UNLOCK,      UNLOCK)       \
-  XX(16, BIND,        BIND)         \
-  XX(17, REBIND,      REBIND)       \
-  XX(18, UNBIND,      UNBIND)       \
-  XX(19, ACL,         ACL)          \
-  /* subversion */                  \
-  XX(20, REPORT,      REPORT)       \
-  XX(21, MKACTIVITY,  MKACTIVITY)   \
-  XX(22, CHECKOUT,    CHECKOUT)     \
-  XX(23, MERGE,       MERGE)        \
-  /* upnp */                        \
-  XX(24, MSEARCH,     M-SEARCH)     \
-  XX(25, NOTIFY,      NOTIFY)       \
-  XX(26, SUBSCRIBE,   SUBSCRIBE)    \
-  XX(27, UNSUBSCRIBE, UNSUBSCRIBE)  \
-  /* RFC-5789 */                    \
-  XX(28, PATCH,       PATCH)        \
-  XX(29, PURGE,       PURGE)        \
-  /* CalDAV */                      \
-  XX(30, MKCALENDAR,  MKCALENDAR)   \
-  /* RFC-2068, section 19.6.1.2 */  \
-  XX(31, LINK,        LINK)         \
-  XX(32, UNLINK,      UNLINK)       \
-  /* icecast */                     \
-  XX(33, SOURCE,      SOURCE)       \
-
-enum http_method
-  {
-#define XX(num, name, string) HTTP_##name = num,
-  HTTP_METHOD_MAP(XX)
-#undef XX
-  };
-
-
-enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
-
-
-/* Flag values for http_parser.flags field */
-enum flags
-  { F_CHUNKED               = 1 << 0
-  , F_CONNECTION_KEEP_ALIVE = 1 << 1
-  , F_CONNECTION_CLOSE      = 1 << 2
-  , F_CONNECTION_UPGRADE    = 1 << 3
-  , F_TRAILING              = 1 << 4
-  , F_UPGRADE               = 1 << 5
-  , F_SKIPBODY              = 1 << 6
-  , F_CONTENTLENGTH         = 1 << 7
-  };
-
-
-/* Map for errno-related constants
- *
- * The provided argument should be a macro that takes 2 arguments.
- */
-#define HTTP_ERRNO_MAP(XX)                                           \
-  /* No error */                                                     \
-  XX(OK, "success")                                                  \
-                                                                     \
-  /* Callback-related errors */                                      \
-  XX(CB_message_begin, "the on_message_begin callback failed")       \
-  XX(CB_url, "the on_url callback failed")                           \
-  XX(CB_header_field, "the on_header_field callback failed")         \
-  XX(CB_header_value, "the on_header_value callback failed")         \
-  XX(CB_headers_complete, "the on_headers_complete callback failed") \
-  XX(CB_body, "the on_body callback failed")                         \
-  XX(CB_message_complete, "the on_message_complete callback failed") \
-  XX(CB_status, "the on_status callback failed")                     \
-  XX(CB_chunk_header, "the on_chunk_header callback failed")         \
-  XX(CB_chunk_complete, "the on_chunk_complete callback failed")     \
-                                                                     \
-  /* Parsing-related errors */                                       \
-  XX(INVALID_EOF_STATE, "stream ended at an unexpected time")        \
-  XX(HEADER_OVERFLOW,                                                \
-     "too many header bytes seen; overflow detected")                \
-  XX(CLOSED_CONNECTION,                                              \
-     "data received after completed connection: close message")      \
-  XX(INVALID_VERSION, "invalid HTTP version")                        \
-  XX(INVALID_STATUS, "invalid HTTP status code")                     \
-  XX(INVALID_METHOD, "invalid HTTP method")                          \
-  XX(INVALID_URL, "invalid URL")                                     \
-  XX(INVALID_HOST, "invalid host")                                   \
-  XX(INVALID_PORT, "invalid port")                                   \
-  XX(INVALID_PATH, "invalid path")                                   \
-  XX(INVALID_QUERY_STRING, "invalid query string")                   \
-  XX(INVALID_FRAGMENT, "invalid fragment")                           \
-  XX(LF_EXPECTED, "LF character expected")                           \
-  XX(INVALID_HEADER_TOKEN, "invalid character in header")            \
-  XX(INVALID_CONTENT_LENGTH,                                         \
-     "invalid character in content-length header")                   \
-  XX(UNEXPECTED_CONTENT_LENGTH,                                      \
-     "unexpected content-length header")                             \
-  XX(INVALID_CHUNK_SIZE,                                             \
-     "invalid character in chunk size header")                       \
-  XX(INVALID_CONSTANT, "invalid constant string")                    \
-  XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
-  XX(STRICT, "strict mode assertion failed")                         \
-  XX(PAUSED, "parser is paused")                                     \
-  XX(UNKNOWN, "an unknown error occurred")
-
-
-/* Define HPE_* values for each errno value above */
-#define HTTP_ERRNO_GEN(n, s) HPE_##n,
-enum http_errno {
-  HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-};
-#undef HTTP_ERRNO_GEN
-
-
-/* Get an http_errno value from an http_parser */
-#define HTTP_PARSER_ERRNO(p)            ((::wpi::http_errno) (p)->http_errno)
-
-
-struct http_parser {
-  /** PRIVATE **/
-  unsigned int type : 2;         /* enum http_parser_type */
-  unsigned int flags : 8;        /* F_* values from 'flags' enum; semi-public */
-  unsigned int state : 7;        /* enum state from http_parser.c */
-  unsigned int header_state : 7; /* enum header_state from http_parser.c */
-  unsigned int index : 7;        /* index into current matcher */
-  unsigned int lenient_http_headers : 1;
-
-  uint32_t nread;          /* # bytes read in various scenarios */
-  uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
-
-  /** READ-ONLY **/
-  unsigned short http_major;
-  unsigned short http_minor;
-  unsigned int status_code : 16; /* responses only */
-  unsigned int method : 8;       /* requests only */
-  unsigned int http_errno : 7;
-
-  /* 1 = Upgrade header was present and the parser has exited because of that.
-   * 0 = No upgrade header present.
-   * Should be checked when http_parser_execute() returns in addition to
-   * error checking.
-   */
-  unsigned int upgrade : 1;
-
-  /** PUBLIC **/
-  void *data; /* A pointer to get hook to the "connection" or "socket" object */
-};
-
-
-struct http_parser_settings {
-  http_cb      on_message_begin;
-  http_data_cb on_url;
-  http_data_cb on_status;
-  http_data_cb on_header_field;
-  http_data_cb on_header_value;
-  http_cb      on_headers_complete;
-  http_data_cb on_body;
-  http_cb      on_message_complete;
-  /* When on_chunk_header is called, the current chunk length is stored
-   * in parser->content_length.
-   */
-  http_cb      on_chunk_header;
-  http_cb      on_chunk_complete;
-};
-
-
-enum http_parser_url_fields
-  { UF_SCHEMA           = 0
-  , UF_HOST             = 1
-  , UF_PORT             = 2
-  , UF_PATH             = 3
-  , UF_QUERY            = 4
-  , UF_FRAGMENT         = 5
-  , UF_USERINFO         = 6
-  , UF_MAX              = 7
-  };
-
-
-/* Result structure for http_parser_parse_url().
- *
- * Callers should index into field_data[] with UF_* values iff field_set
- * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
- * because we probably have padding left over), we convert any port to
- * a uint16_t.
- */
-struct http_parser_url {
-  uint16_t field_set;           /* Bitmask of (1 << UF_*) values */
-  uint16_t port;                /* Converted UF_PORT string */
-
-  struct {
-    uint16_t off;               /* Offset into buffer in which field starts */
-    uint16_t len;               /* Length of run in buffer */
-  } field_data[UF_MAX];
-};
-
-
-/* Returns the library version. Bits 16-23 contain the major version number,
- * bits 8-15 the minor version number and bits 0-7 the patch level.
- * Usage example:
- *
- *   unsigned long version = http_parser_version();
- *   unsigned major = (version >> 16) & 255;
- *   unsigned minor = (version >> 8) & 255;
- *   unsigned patch = version & 255;
- *   printf("http_parser v%u.%u.%u\n", major, minor, patch);
- */
-unsigned long http_parser_version(void);
-
-void http_parser_init(http_parser *parser, enum http_parser_type type);
-
-
-/* Initialize http_parser_settings members to 0
- */
-void http_parser_settings_init(http_parser_settings *settings);
-
-
-/* Executes the parser. Returns number of parsed bytes. Sets
- * `parser->http_errno` on error. */
-size_t http_parser_execute(http_parser *parser,
-                           const http_parser_settings *settings,
-                           const char *data,
-                           size_t len);
-
-
-/* If http_should_keep_alive() in the on_headers_complete or
- * on_message_complete callback returns 0, then this should be
- * the last message on the connection.
- * If you are the server, respond with the "Connection: close" header.
- * If you are the client, close the connection.
- */
-int http_should_keep_alive(const http_parser *parser);
-
-/* Returns a string version of the HTTP method. */
-const char *http_method_str(enum http_method m);
-
-/* Returns a string version of the HTTP status code. */
-const char *http_status_str(enum http_status s);
-
-/* Return a string name of the given error */
-const char *http_errno_name(enum http_errno err);
-
-/* Return a string description of the given error */
-const char *http_errno_description(enum http_errno err);
-
-/* Initialize all http_parser_url members to 0 */
-void http_parser_url_init(struct http_parser_url *u);
-
-/* Parse a URL; return nonzero on failure */
-int http_parser_parse_url(const char *buf, size_t buflen,
-                          int is_connect,
-                          struct http_parser_url *u);
-
-/* Pause or un-pause the parser; a nonzero value pauses */
-void http_parser_pause(http_parser *parser, int paused);
-
-/* Checks if this is the final chunk of the body. */
-int http_body_is_final(const http_parser *parser);
-
-}  // namespace wpi
-
-#endif
diff --git a/wpiutil/src/main/native/include/wpi/interpolating_map.h b/wpiutil/src/main/native/include/wpi/interpolating_map.h
new file mode 100644
index 0000000..5eff514
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/interpolating_map.h
@@ -0,0 +1,87 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <map>
+#include <utility>
+
+namespace wpi {
+
+/**
+ * Implements a table of key-value pairs with linear interpolation between
+ * values.
+ *
+ * If there's no matching key, the value returned will be a linear interpolation
+ * between the keys before and after the provided one.
+ *
+ * @tparam Key   The key type.
+ * @tparam Value The value type.
+ */
+template <typename Key, typename Value>
+class interpolating_map {
+ public:
+  /**
+   * Inserts a key-value pair.
+   *
+   * @param key   The key.
+   * @param value The value.
+   */
+  void insert(const Key& key, const Value& value) {
+    m_container.insert(std::make_pair(key, value));
+  }
+
+  /**
+   * Inserts a key-value pair.
+   *
+   * @param key   The key.
+   * @param value The value.
+   */
+  void insert(Key&& key, Value&& value) {
+    m_container.insert(std::make_pair(key, value));
+  }
+
+  /**
+   * Returns the value associated with a given key.
+   *
+   * If there's no matching key, the value returned will be a linear
+   * interpolation between the keys before and after the provided one.
+   *
+   * @param key The key.
+   */
+  Value operator[](const Key& key) const {
+    using const_iterator = typename std::map<Key, Value>::const_iterator;
+
+    // Get iterator to upper bound key-value pair for the given key
+    const_iterator upper = m_container.upper_bound(key);
+
+    // If key > largest key in table, return value for largest table key
+    if (upper == m_container.end()) {
+      return (--upper)->second;
+    }
+
+    // If key <= smallest key in table, return value for smallest table key
+    if (upper == m_container.begin()) {
+      return upper->second;
+    }
+
+    // Get iterator to lower bound key-value pair
+    const_iterator lower = upper;
+    --lower;
+
+    // Perform linear interpolation between lower and upper bound
+    const double delta = (key - lower->first) / (upper->first - lower->first);
+    return delta * upper->second + (1.0 - delta) * lower->second;
+  }
+
+  /**
+   * Clears the contents.
+   */
+  void clear() { m_container.clear(); }
+
+ private:
+  std::map<Key, Value> m_container;
+};
+
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/jni_util.h b/wpiutil/src/main/native/include/wpi/jni_util.h
index 585c1c6..8d50fdd 100644
--- a/wpiutil/src/main/native/include/wpi/jni_util.h
+++ b/wpiutil/src/main/native/include/wpi/jni_util.h
@@ -8,6 +8,7 @@
 #include <jni.h>
 
 #include <queue>
+#include <span>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -21,7 +22,6 @@
 #include "wpi/StringExtras.h"
 #include "wpi/mutex.h"
 #include "wpi/raw_ostream.h"
-#include "wpi/span.h"
 
 /** Java Native Interface (JNI) utility functions */
 namespace wpi::java {
@@ -154,7 +154,7 @@
       jsize size = env->GetStringLength(str);
       const jchar* chars = env->GetStringCritical(str, nullptr);
       if (chars) {
-        convertUTF16ToUTF8String(wpi::span<const jchar>(chars, size), m_str);
+        convertUTF16ToUTF8String(std::span<const jchar>(chars, size), m_str);
         env->ReleaseStringCritical(str, chars);
       }
     } else {
@@ -179,10 +179,16 @@
 namespace detail {
 
 template <typename C, typename T>
-class JArrayRefInner {};
+class JArrayRefInner {
+ public:
+  operator std::span<const T>() const {  // NOLINT
+    return static_cast<const C*>(this)->array();
+  }
+};
 
 /**
- * Specialization of JArrayRefBase to provide std::string_view conversion.
+ * Specialization of JArrayRefBase to provide std::string_view conversion
+ * and span<const uint8_t> conversion.
  */
 template <typename C>
 class JArrayRefInner<C, jbyte> {
@@ -196,6 +202,33 @@
     }
     return {reinterpret_cast<const char*>(arr.data()), arr.size()};
   }
+
+  std::span<const uint8_t> uarray() const {
+    auto arr = static_cast<const C*>(this)->array();
+    if (arr.empty()) {
+      return {};
+    }
+    return {reinterpret_cast<const uint8_t*>(arr.data()), arr.size()};
+  }
+};
+
+/**
+ * Specialization of JArrayRefBase to handle both "long long" and "long" on
+ * 64-bit systems.
+ */
+template <typename C>
+class JArrayRefInner<C, jlong> {
+ public:
+  template <typename U,
+            typename = std::enable_if_t<sizeof(U) == sizeof(jlong) &&
+                                        std::is_integral_v<U>>>
+  operator std::span<const U>() const {  // NOLINT
+    auto arr = static_cast<const C*>(this)->array();
+    if (arr.empty()) {
+      return {};
+    }
+    return {reinterpret_cast<const U*>(arr.data()), arr.size()};
+  }
 };
 
 /**
@@ -206,9 +239,7 @@
  public:
   explicit operator bool() const { return this->m_elements != nullptr; }
 
-  operator span<const T>() const { return array(); }  // NOLINT
-
-  span<const T> array() const {
+  std::span<const T> array() const {
     if (!this->m_elements) {
       return {};
     }
@@ -375,7 +406,7 @@
 template <typename T,
           bool = (std::is_integral<T>::value && sizeof(jint) == sizeof(T))>
 struct ConvertIntArray {
-  static jintArray ToJava(JNIEnv* env, span<const T> arr) {
+  static jintArray ToJava(JNIEnv* env, std::span<const T> arr) {
     jintArray jarr = env->NewIntArray(arr.size());
     if (!jarr) {
       return nullptr;
@@ -398,7 +429,7 @@
  */
 template <typename T>
 struct ConvertIntArray<T, true> {
-  static jintArray ToJava(JNIEnv* env, span<const T> arr) {
+  static jintArray ToJava(JNIEnv* env, std::span<const T> arr) {
     jintArray jarr = env->NewIntArray(arr.size());
     if (!jarr) {
       return nullptr;
@@ -418,7 +449,7 @@
  * @param arr Span to convert.
  */
 template <typename T>
-inline jintArray MakeJIntArray(JNIEnv* env, span<const T> arr) {
+inline jintArray MakeJIntArray(JNIEnv* env, std::span<const T> arr) {
   return detail::ConvertIntArray<T>::ToJava(env, arr);
 }
 
@@ -429,7 +460,7 @@
  * @param arr Span to convert.
  */
 template <typename T>
-inline jintArray MakeJIntArray(JNIEnv* env, span<T> arr) {
+inline jintArray MakeJIntArray(JNIEnv* env, std::span<T> arr) {
   return detail::ConvertIntArray<T>::ToJava(env, arr);
 }
 
@@ -462,12 +493,12 @@
 }
 
 /**
- * Convert a std::string_view into a jbyteArray.
+ * Convert a span into a jbyteArray.
  *
  * @param env JRE environment.
- * @param str std::string_view to convert.
+ * @param str span to convert.
  */
-inline jbyteArray MakeJByteArray(JNIEnv* env, std::string_view str) {
+inline jbyteArray MakeJByteArray(JNIEnv* env, std::span<const uint8_t> str) {
   jbyteArray jarr = env->NewByteArray(str.size());
   if (!jarr) {
     return nullptr;
@@ -483,7 +514,7 @@
  * @param env JRE environment.
  * @param arr Array to convert.
  */
-inline jbooleanArray MakeJBooleanArray(JNIEnv* env, span<const int> arr) {
+inline jbooleanArray MakeJBooleanArray(JNIEnv* env, std::span<const int> arr) {
   jbooleanArray jarr = env->NewBooleanArray(arr.size());
   if (!jarr) {
     return nullptr;
@@ -506,7 +537,7 @@
  * @param env JRE environment.
  * @param arr Array to convert.
  */
-inline jbooleanArray MakeJBooleanArray(JNIEnv* env, span<const bool> arr) {
+inline jbooleanArray MakeJBooleanArray(JNIEnv* env, std::span<const bool> arr) {
   jbooleanArray jarr = env->NewBooleanArray(arr.size());
   if (!jarr) {
     return nullptr;
@@ -525,32 +556,45 @@
 
 // Other MakeJ*Array conversions.
 
-#define WPI_JNI_MAKEJARRAY(T, F)                                    \
-  inline T##Array MakeJ##F##Array(JNIEnv* env, span<const T> arr) { \
-    T##Array jarr = env->New##F##Array(arr.size());                 \
-    if (!jarr) {                                                    \
-      return nullptr;                                               \
-    }                                                               \
-    env->Set##F##ArrayRegion(jarr, 0, arr.size(), arr.data());      \
-    return jarr;                                                    \
+#define WPI_JNI_MAKEJARRAY(T, F)                                         \
+  inline T##Array MakeJ##F##Array(JNIEnv* env, std::span<const T> arr) { \
+    T##Array jarr = env->New##F##Array(arr.size());                      \
+    if (!jarr) {                                                         \
+      return nullptr;                                                    \
+    }                                                                    \
+    env->Set##F##ArrayRegion(jarr, 0, arr.size(), arr.data());           \
+    return jarr;                                                         \
   }
 
 WPI_JNI_MAKEJARRAY(jboolean, Boolean)
 WPI_JNI_MAKEJARRAY(jbyte, Byte)
 WPI_JNI_MAKEJARRAY(jshort, Short)
-WPI_JNI_MAKEJARRAY(jlong, Long)
 WPI_JNI_MAKEJARRAY(jfloat, Float)
 WPI_JNI_MAKEJARRAY(jdouble, Double)
 
 #undef WPI_JNI_MAKEJARRAY
 
+template <class T, typename = std::enable_if_t<
+                       sizeof(typename T::value_type) == sizeof(jlong) &&
+                       std::is_integral_v<typename T::value_type>>>
+inline jlongArray MakeJLongArray(JNIEnv* env, const T& arr) {
+  jlongArray jarr = env->NewLongArray(arr.size());
+  if (!jarr) {
+    return nullptr;
+  }
+  env->SetLongArrayRegion(jarr, 0, arr.size(),
+                          reinterpret_cast<const jlong*>(arr.data()));
+  return jarr;
+}
+
 /**
  * Convert an array of std::string into a jarray of jstring.
  *
  * @param env JRE environment.
  * @param arr Array to convert.
  */
-inline jobjectArray MakeJStringArray(JNIEnv* env, span<const std::string> arr) {
+inline jobjectArray MakeJStringArray(JNIEnv* env,
+                                     std::span<const std::string> arr) {
   static JClass stringCls{env, "java/lang/String"};
   if (!stringCls) {
     return nullptr;
@@ -572,7 +616,8 @@
  * @param env JRE environment.
  * @param arr Array to convert.
  */
-inline jobjectArray MakeJStringArray(JNIEnv* env, span<std::string_view> arr) {
+inline jobjectArray MakeJStringArray(JNIEnv* env,
+                                     std::span<std::string_view> arr) {
   static JClass stringCls{env, "java/lang/String"};
   if (!stringCls) {
     return nullptr;
diff --git a/wpiutil/src/main/native/include/wpi/leb128.h b/wpiutil/src/main/native/include/wpi/leb128.h
index 04752c6..e89d505 100644
--- a/wpiutil/src/main/native/include/wpi/leb128.h
+++ b/wpiutil/src/main/native/include/wpi/leb128.h
@@ -8,8 +8,7 @@
 #include <stdint.h>
 
 #include <optional>
-
-#include "wpi/span.h"
+#include <span>
 
 namespace wpi {
 
@@ -100,7 +99,7 @@
    *           is left when function returns).
    * @return value (in std::optional)
    */
-  std::optional<uint64_t> ReadOne(span<const uint8_t>* in);
+  std::optional<uint64_t> ReadOne(std::span<const uint8_t>* in);
 
  private:
   uint64_t m_result = 0;
diff --git a/wpiutil/src/main/native/include/wpi/math b/wpiutil/src/main/native/include/wpi/math
deleted file mode 100644
index 25f2a64..0000000
--- a/wpiutil/src/main/native/include/wpi/math
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include "wpi/numbers"
-
-// clang-format off
-#ifdef _MSC_VER
-#pragma message("warning: Use <wpi/numbers> and wpi::numbers instead to reflect C++20 <numbers> and std::numbers")
-#else
-#warning "Use <wpi/numbers> and wpi::numbers instead to reflect C++20 <numbers> and std::numbers"
-#endif
-
-// clang-format on
-
-namespace wpi::math {
-using namespace wpi::numbers;
-}  // namespace wpi::math
diff --git a/wpiutil/src/main/native/include/wpi/numbers b/wpiutil/src/main/native/include/wpi/numbers
deleted file mode 100644
index d45aee0..0000000
--- a/wpiutil/src/main/native/include/wpi/numbers
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <type_traits>
-
-namespace wpi::numbers {
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T e_v = 2.718281828459045235360287471352662498L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T log2e_v = 1.442695040888963407359924681001892137L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T log10e_v = 0.434294481903251827651128918916605082L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T pi_v = 3.141592653589793238462643383279502884L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T inv_pi_v = 0.318309886183790671537767526745028724L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T inv_sqrtpi_v = 0.564189583547756286948079451560772586L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T ln2_v = 0.693147180559945309417232121458176568L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T ln10_v = 2.302585092994045684017991454684364208L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T sqrt2_v = 1.414213562373095048801688724209698078L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T sqrt3_v = 1.732050807568877293527446341505872366L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T inv_sqrt3_v = 0.577350269189625764509148780501957456L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T egamma_v = 0.577215664901532860606512090082402431L;
-
-template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
-inline constexpr T phi_v = 1.618033988749894848204586834365638117L;
-
-inline constexpr double e = e_v<double>;
-inline constexpr double log2e = log2e_v<double>;
-inline constexpr double log10e = log10e_v<double>;
-inline constexpr double pi = pi_v<double>;
-inline constexpr double inv_pi = inv_pi_v<double>;
-inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
-inline constexpr double ln2 = ln2_v<double>;
-inline constexpr double ln10 = ln10_v<double>;
-inline constexpr double sqrt2 = sqrt2_v<double>;
-inline constexpr double sqrt3 = sqrt3_v<double>;
-inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
-inline constexpr double egamma = egamma_v<double>;
-inline constexpr double phi = phi_v<double>;
-
-}  // namespace wpi::numbers
diff --git a/wpiutil/src/main/native/include/wpi/raw_istream.h b/wpiutil/src/main/native/include/wpi/raw_istream.h
index 2371fc6..2f278c8 100644
--- a/wpiutil/src/main/native/include/wpi/raw_istream.h
+++ b/wpiutil/src/main/native/include/wpi/raw_istream.h
@@ -9,13 +9,13 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <span>
 #include <string>
 #include <string_view>
 #include <system_error>
 #include <vector>
 
 #include "wpi/SmallVector.h"
-#include "wpi/span.h"
 
 namespace wpi {
 
@@ -133,9 +133,9 @@
   // not const as we don't want to allow temporaries
   explicit raw_mem_istream(std::string& str)
       : raw_mem_istream(str.data(), str.size()) {}
-  explicit raw_mem_istream(span<const char> mem)
+  explicit raw_mem_istream(std::span<const char> mem)
       : raw_mem_istream(mem.data(), mem.size()) {}
-  explicit raw_mem_istream(span<const uint8_t> mem)
+  explicit raw_mem_istream(std::span<const uint8_t> mem)
       : raw_mem_istream(reinterpret_cast<const char*>(mem.data()), mem.size()) {
   }
   explicit raw_mem_istream(const char* str)
diff --git a/wpiutil/src/main/native/include/wpi/raw_socket_istream.h b/wpiutil/src/main/native/include/wpi/raw_socket_istream.h
deleted file mode 100644
index f6899e2..0000000
--- a/wpiutil/src/main/native/include/wpi/raw_socket_istream.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_RAW_SOCKET_ISTREAM_H_
-#define WPIUTIL_WPI_RAW_SOCKET_ISTREAM_H_
-
-#include "wpi/raw_istream.h"
-
-namespace wpi {
-
-class NetworkStream;
-
-class raw_socket_istream : public raw_istream {
- public:
-  explicit raw_socket_istream(NetworkStream& stream, int timeout = 0)
-      : m_stream(stream), m_timeout(timeout) {}
-
-  void close() override;
-  size_t in_avail() const override;
-
- private:
-  void read_impl(void* data, size_t len) override;
-
-  NetworkStream& m_stream;
-  int m_timeout;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_RAW_SOCKET_ISTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/raw_socket_ostream.h b/wpiutil/src/main/native/include/wpi/raw_socket_ostream.h
deleted file mode 100644
index 5cdeb41..0000000
--- a/wpiutil/src/main/native/include/wpi/raw_socket_ostream.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_RAW_SOCKET_OSTREAM_H_
-#define WPIUTIL_WPI_RAW_SOCKET_OSTREAM_H_
-
-#include "wpi/raw_ostream.h"
-
-namespace wpi {
-
-class NetworkStream;
-
-class raw_socket_ostream : public raw_ostream {
- public:
-  raw_socket_ostream(NetworkStream& stream, bool shouldClose)
-      : m_stream(stream), m_shouldClose(shouldClose) {}
-  ~raw_socket_ostream() override;
-
-  void close();
-
-  bool has_error() const { return m_error; }
-  void clear_error() { m_error = false; }
-
- protected:
-  void error_detected() { m_error = true; }
-
- private:
-  void write_impl(const char* data, size_t len) override;
-  uint64_t current_pos() const override;
-
-  NetworkStream& m_stream;
-  bool m_error = false;
-  bool m_shouldClose;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_RAW_SOCKET_OSTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/raw_uv_ostream.h b/wpiutil/src/main/native/include/wpi/raw_uv_ostream.h
deleted file mode 100644
index 4773c61..0000000
--- a/wpiutil/src/main/native/include/wpi/raw_uv_ostream.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_RAW_UV_OSTREAM_H_
-#define WPIUTIL_WPI_RAW_UV_OSTREAM_H_
-
-#include <functional>
-#include <utility>
-
-#include "wpi/SmallVector.h"
-#include "wpi/raw_ostream.h"
-#include "wpi/span.h"
-#include "wpi/uv/Buffer.h"
-
-namespace wpi {
-
-/**
- * raw_ostream style output to a SmallVector of uv::Buffer buffers.  Fixed-size
- * buffers are allocated and appended as necessary to fit the data being output.
- * The SmallVector need not be empty at start.
- */
-class raw_uv_ostream : public raw_ostream {
- public:
-  /**
-   * Construct a new raw_uv_ostream.
-   * @param bufs Buffers vector.  NOT cleared on construction.
-   * @param allocSize Size to allocate for each buffer; allocation will be
-   *                  performed using Buffer::Allocate().
-   */
-  raw_uv_ostream(SmallVectorImpl<uv::Buffer>& bufs, size_t allocSize)
-      : m_bufs(bufs), m_alloc([=] { return uv::Buffer::Allocate(allocSize); }) {
-    SetUnbuffered();
-  }
-
-  /**
-   * Construct a new raw_uv_ostream.
-   * @param bufs Buffers vector.  NOT cleared on construction.
-   * @param alloc Allocator.
-   */
-  raw_uv_ostream(SmallVectorImpl<uv::Buffer>& bufs,
-                 std::function<uv::Buffer()> alloc)
-      : m_bufs(bufs), m_alloc(std::move(alloc)) {
-    SetUnbuffered();
-  }
-
-  ~raw_uv_ostream() override = default;
-
-  /**
-   * Returns an span to the buffers.
-   */
-  span<uv::Buffer> bufs() { return m_bufs; }
-
-  void flush() = delete;
-
-  /**
-   * Resets the amount of allocated space.
-   */
-  void reset() { m_left = 0; }
-
- private:
-  void write_impl(const char* data, size_t len) override;
-  uint64_t current_pos() const override;
-
-  SmallVectorImpl<uv::Buffer>& m_bufs;
-  std::function<uv::Buffer()> m_alloc;
-
-  // How much allocated space is left in the current buffer.
-  size_t m_left = 0;
-};
-
-}  // namespace wpi
-
-#endif  // WPIUTIL_WPI_RAW_UV_OSTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/scope b/wpiutil/src/main/native/include/wpi/scope
new file mode 100644
index 0000000..e25badb
--- /dev/null
+++ b/wpiutil/src/main/native/include/wpi/scope
@@ -0,0 +1,37 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <utility>
+
+namespace wpi {
+
+template <typename F>
+class scope_exit {
+ public:
+  explicit scope_exit(F&& f) noexcept : m_f{std::forward<F>(f)} {}
+
+  ~scope_exit() {
+    if (m_active) {
+      m_f();
+    }
+  }
+
+  scope_exit(scope_exit&& rhs) noexcept
+      : m_f{std::move(rhs.m_f)}, m_active{rhs.m_active} {
+    rhs.release();
+  }
+
+  scope_exit(const scope_exit&) = delete;
+  scope_exit& operator=(const scope_exit&) = delete;
+
+  void release() noexcept { m_active = false; }
+
+ private:
+  F m_f;
+  bool m_active = true;
+};
+
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/sendable/SendableBuilder.h b/wpiutil/src/main/native/include/wpi/sendable/SendableBuilder.h
index e092a1e..2287b73 100644
--- a/wpiutil/src/main/native/include/wpi/sendable/SendableBuilder.h
+++ b/wpiutil/src/main/native/include/wpi/sendable/SendableBuilder.h
@@ -6,12 +6,12 @@
 
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
 #include <string_view>
 #include <vector>
 
 #include "wpi/SmallVector.h"
-#include "wpi/span.h"
 
 namespace wpi {
 
@@ -60,6 +60,28 @@
                                   std::function<void(bool)> setter) = 0;
 
   /**
+   * Add an integer property.
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddIntegerProperty(std::string_view key,
+                                  std::function<int64_t()> getter,
+                                  std::function<void(int64_t)> setter) = 0;
+
+  /**
+   * Add a float property.
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddFloatProperty(std::string_view key,
+                                std::function<float()> getter,
+                                std::function<void(float)> setter) = 0;
+
+  /**
    * Add a double property.
    *
    * @param key     property name
@@ -90,7 +112,29 @@
    */
   virtual void AddBooleanArrayProperty(
       std::string_view key, std::function<std::vector<int>()> getter,
-      std::function<void(wpi::span<const int>)> setter) = 0;
+      std::function<void(std::span<const int>)> setter) = 0;
+
+  /**
+   * Add an integer array property.
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddIntegerArrayProperty(
+      std::string_view key, std::function<std::vector<int64_t>()> getter,
+      std::function<void(std::span<const int64_t>)> setter) = 0;
+
+  /**
+   * Add a float array property.
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddFloatArrayProperty(
+      std::string_view key, std::function<std::vector<float>()> getter,
+      std::function<void(std::span<const float>)> setter) = 0;
 
   /**
    * Add a double array property.
@@ -101,7 +145,7 @@
    */
   virtual void AddDoubleArrayProperty(
       std::string_view key, std::function<std::vector<double>()> getter,
-      std::function<void(wpi::span<const double>)> setter) = 0;
+      std::function<void(std::span<const double>)> setter) = 0;
 
   /**
    * Add a string array property.
@@ -112,18 +156,20 @@
    */
   virtual void AddStringArrayProperty(
       std::string_view key, std::function<std::vector<std::string>()> getter,
-      std::function<void(wpi::span<const std::string>)> setter) = 0;
+      std::function<void(std::span<const std::string>)> setter) = 0;
 
   /**
    * Add a raw property.
    *
-   * @param key     property name
-   * @param getter  getter function (returns current value)
-   * @param setter  setter function (sets new value)
+   * @param key         property name
+   * @param typeString  type string
+   * @param getter      getter function (returns current value)
+   * @param setter      setter function (sets new value)
    */
-  virtual void AddRawProperty(std::string_view key,
-                              std::function<std::string()> getter,
-                              std::function<void(std::string_view)> setter) = 0;
+  virtual void AddRawProperty(
+      std::string_view key, std::string_view typeString,
+      std::function<std::vector<uint8_t>()> getter,
+      std::function<void(std::span<const uint8_t>)> setter) = 0;
 
   /**
    * Add a string property (SmallString form).
@@ -146,9 +192,36 @@
    */
   virtual void AddSmallBooleanArrayProperty(
       std::string_view key,
-      std::function<wpi::span<const int>(wpi::SmallVectorImpl<int>& buf)>
+      std::function<std::span<const int>(wpi::SmallVectorImpl<int>& buf)>
           getter,
-      std::function<void(wpi::span<const int>)> setter) = 0;
+      std::function<void(std::span<const int>)> setter) = 0;
+
+  /**
+   * Add an integer array property (SmallVector form).
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddSmallIntegerArrayProperty(
+      std::string_view key,
+      std::function<
+          std::span<const int64_t>(wpi::SmallVectorImpl<int64_t>& buf)>
+          getter,
+      std::function<void(std::span<const int64_t>)> setter) = 0;
+
+  /**
+   * Add a float array property (SmallVector form).
+   *
+   * @param key     property name
+   * @param getter  getter function (returns current value)
+   * @param setter  setter function (sets new value)
+   */
+  virtual void AddSmallFloatArrayProperty(
+      std::string_view key,
+      std::function<std::span<const float>(wpi::SmallVectorImpl<float>& buf)>
+          getter,
+      std::function<void(std::span<const float>)> setter) = 0;
 
   /**
    * Add a double array property (SmallVector form).
@@ -159,9 +232,9 @@
    */
   virtual void AddSmallDoubleArrayProperty(
       std::string_view key,
-      std::function<wpi::span<const double>(wpi::SmallVectorImpl<double>& buf)>
+      std::function<std::span<const double>(wpi::SmallVectorImpl<double>& buf)>
           getter,
-      std::function<void(wpi::span<const double>)> setter) = 0;
+      std::function<void(std::span<const double>)> setter) = 0;
 
   /**
    * Add a string array property (SmallVector form).
@@ -173,21 +246,23 @@
   virtual void AddSmallStringArrayProperty(
       std::string_view key,
       std::function<
-          wpi::span<const std::string>(wpi::SmallVectorImpl<std::string>& buf)>
+          std::span<const std::string>(wpi::SmallVectorImpl<std::string>& buf)>
           getter,
-      std::function<void(wpi::span<const std::string>)> setter) = 0;
+      std::function<void(std::span<const std::string>)> setter) = 0;
 
   /**
    * Add a raw property (SmallVector form).
    *
    * @param key     property name
+   * @param typeString  type string
    * @param getter  getter function (returns current value)
    * @param setter  setter function (sets new value)
    */
   virtual void AddSmallRawProperty(
-      std::string_view key,
-      std::function<std::string_view(wpi::SmallVectorImpl<char>& buf)> getter,
-      std::function<void(std::string_view)> setter) = 0;
+      std::string_view key, std::string_view typeString,
+      std::function<std::span<uint8_t>(wpi::SmallVectorImpl<uint8_t>& buf)>
+          getter,
+      std::function<void(std::span<const uint8_t>)> setter) = 0;
 
   /**
    * Gets the kind of backend being used.
diff --git a/wpiutil/src/main/native/include/wpi/sendable/SendableHelper.h b/wpiutil/src/main/native/include/wpi/sendable/SendableHelper.h
index 5b6bbe3..f8dd703 100644
--- a/wpiutil/src/main/native/include/wpi/sendable/SendableHelper.h
+++ b/wpiutil/src/main/native/include/wpi/sendable/SendableHelper.h
@@ -4,11 +4,6 @@
 
 #pragma once
 
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/deprecated.h"
 #include "wpi/sendable/SendableRegistry.h"
 
 namespace wpi {
@@ -48,123 +43,6 @@
     return *this;
   }
 
-  /**
-   * Gets the name of this Sendable object.
-   *
-   * @deprecated use SendableRegistry::GetName()
-   *
-   * @return Name
-   */
-  WPI_DEPRECATED("use SendableRegistry::GetName()")
-  std::string GetName() const {
-    return SendableRegistry::GetName(static_cast<const Derived*>(this));
-  }
-
-  /**
-   * Sets the name of this Sendable object.
-   *
-   * @deprecated use SendableRegistry::SetName()
-   *
-   * @param name name
-   */
-  WPI_DEPRECATED("use SendableRegistry::SetName()")
-  void SetName(std::string_view name) {
-    SendableRegistry::SetName(static_cast<Derived*>(this), name);
-  }
-
-  /**
-   * Sets both the subsystem name and device name of this Sendable object.
-   *
-   * @deprecated use SendableRegistry::SetName()
-   *
-   * @param subsystem subsystem name
-   * @param name device name
-   */
-  WPI_DEPRECATED("use SendableRegistry::SetName()")
-  void SetName(std::string_view subsystem, std::string_view name) {
-    SendableRegistry::SetName(static_cast<Derived*>(this), subsystem, name);
-  }
-
-  /**
-   * Gets the subsystem name of this Sendable object.
-   *
-   * @deprecated use SendableRegistry::GetSubsystem().
-   *
-   * @return Subsystem name
-   */
-  WPI_DEPRECATED("use SendableRegistry::GetSubsystem()")
-  std::string GetSubsystem() const {
-    return SendableRegistry::GetSubsystem(static_cast<const Derived*>(this));
-  }
-
-  /**
-   * Sets the subsystem name of this Sendable object.
-   *
-   * @deprecated use SendableRegistry::SetSubsystem()
-   *
-   * @param subsystem subsystem name
-   */
-  WPI_DEPRECATED("use SendableRegistry::SetSubsystem()")
-  void SetSubsystem(std::string_view subsystem) {
-    SendableRegistry::SetSubsystem(static_cast<Derived*>(this), subsystem);
-  }
-
- protected:
-  /**
-   * Add a child component.
-   *
-   * @deprecated use SendableRegistry::AddChild()
-   *
-   * @param child child component
-   */
-  WPI_DEPRECATED("use SendableRegistry::AddChild()")
-  void AddChild(std::shared_ptr<Sendable> child) {
-    SendableRegistry::AddChild(static_cast<Derived*>(this), child.get());
-  }
-
-  /**
-   * Add a child component.
-   *
-   * @deprecated use SendableRegistry::AddChild()
-   *
-   * @param child child component
-   */
-  WPI_DEPRECATED("use SendableRegistry::AddChild()")
-  void AddChild(void* child) {
-    SendableRegistry::AddChild(static_cast<Derived*>(this), child);
-  }
-
-  /**
-   * Sets the name of the sensor with a channel number.
-   *
-   * @deprecated use SendableRegistry::SetName()
-   *
-   * @param moduleType A string that defines the module name in the label for
-   *                   the value
-   * @param channel    The channel number the device is plugged into
-   */
-  WPI_DEPRECATED("use SendableRegistry::SetName()")
-  void SetName(std::string_view moduleType, int channel) {
-    SendableRegistry::SetName(static_cast<Derived*>(this), moduleType, channel);
-  }
-
-  /**
-   * Sets the name of the sensor with a module and channel number.
-   *
-   * @deprecated use SendableRegistry::SetName()
-   *
-   * @param moduleType   A string that defines the module name in the label for
-   *                     the value
-   * @param moduleNumber The number of the particular module type
-   * @param channel      The channel number the device is plugged into (usually
-   * PWM)
-   */
-  WPI_DEPRECATED("use SendableRegistry::SetName()")
-  void SetName(std::string_view moduleType, int moduleNumber, int channel) {
-    SendableRegistry::SetName(static_cast<Derived*>(this), moduleType,
-                              moduleNumber, channel);
-  }
-
  protected:
   SendableHelper() = default;
 
diff --git a/wpiutil/src/main/native/include/wpi/sendable/SendableRegistry.h b/wpiutil/src/main/native/include/wpi/sendable/SendableRegistry.h
index a08f9e9..4639749 100644
--- a/wpiutil/src/main/native/include/wpi/sendable/SendableRegistry.h
+++ b/wpiutil/src/main/native/include/wpi/sendable/SendableRegistry.h
@@ -20,7 +20,7 @@
  * The SendableRegistry class is the public interface for registering sensors
  * and actuators for use on dashboards and LiveWindow.
  */
-class SendableRegistry {
+class SendableRegistry final {
  public:
   SendableRegistry() = delete;
 
diff --git a/wpiutil/src/main/native/include/wpi/span.h b/wpiutil/src/main/native/include/wpi/span.h
deleted file mode 100644
index cf71d79..0000000
--- a/wpiutil/src/main/native/include/wpi/span.h
+++ /dev/null
@@ -1,415 +0,0 @@
-
-/*
-This is an implementation of C++20's std::span
-http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf
-*/
-
-//          Copyright Tristan Brindle 2018.
-// Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file ../../LICENSE_1_0.txt or copy at
-//          https://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef WPIUTIL_WPI_SPAN_HPP_INCLUDED
-#define WPIUTIL_WPI_SPAN_HPP_INCLUDED
-
-#include <array>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#if __cplusplus >= 202002L && __has_include(<span>)
-#include <span>
-#endif
-
-namespace wpi {
-
-inline constexpr std::size_t dynamic_extent = SIZE_MAX;
-
-template <typename ElementType, std::size_t Extent = dynamic_extent>
-class span;
-
-namespace detail {
-
-template <typename E, std::size_t S>
-struct span_storage {
-    constexpr span_storage() noexcept = default;
-
-    constexpr span_storage(E* p_ptr, std::size_t /*unused*/) noexcept
-       : ptr(p_ptr)
-    {}
-
-    E* ptr = nullptr;
-    static constexpr std::size_t size = S;
-};
-
-template <typename E>
-struct span_storage<E, dynamic_extent> {
-    constexpr span_storage() noexcept = default;
-
-    constexpr span_storage(E* p_ptr, std::size_t p_size) noexcept
-        : ptr(p_ptr), size(p_size)
-    {}
-
-    E* ptr = nullptr;
-    std::size_t size = 0;
-};
-
-template <typename T>
-using uncvref_t =
-    typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-template <typename>
-struct is_span : std::false_type {};
-
-template <typename T, std::size_t S>
-struct is_span<span<T, S>> : std::true_type {};
-
-template <typename>
-struct is_std_array : std::false_type {};
-
-template <typename T, std::size_t N>
-struct is_std_array<std::array<T, N>> : std::true_type {};
-
-template <typename, typename = void>
-struct has_size_and_data : std::false_type {};
-
-template <typename T>
-struct has_size_and_data<T, std::void_t<decltype(std::size(std::declval<T>())),
-                                   decltype(std::data(std::declval<T>()))>>
-    : std::true_type {};
-
-template <typename C, typename U = uncvref_t<C>>
-struct is_container {
-    static constexpr bool value =
-        !is_span<U>::value && !is_std_array<U>::value &&
-        !std::is_array<U>::value && has_size_and_data<C>::value;
-};
-
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-template <typename, typename, typename = void>
-struct is_container_element_type_compatible : std::false_type {};
-
-template <typename T, typename E>
-struct is_container_element_type_compatible<
-    T, E,
-    typename std::enable_if<
-        !std::is_same<typename std::remove_cv<decltype(
-                          std::data(std::declval<T>()))>::type,
-                      void>::value>::type>
-    : std::is_convertible<
-          remove_pointer_t<decltype(std::data(std::declval<T>()))> (*)[],
-          E (*)[]> {};
-
-template <typename, typename = size_t>
-struct is_complete : std::false_type {};
-
-template <typename T>
-struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
-
-} // namespace detail
-
-template <typename ElementType, std::size_t Extent>
-class span {
-    static_assert(std::is_object<ElementType>::value,
-                  "A span's ElementType must be an object type (not a "
-                  "reference type or void)");
-    static_assert(detail::is_complete<ElementType>::value,
-                  "A span's ElementType must be a complete type (not a forward "
-                  "declaration)");
-    static_assert(!std::is_abstract<ElementType>::value,
-                  "A span's ElementType cannot be an abstract class type");
-
-    using storage_type = detail::span_storage<ElementType, Extent>;
-
-public:
-    // constants and types
-    using element_type = ElementType;
-    using value_type = typename std::remove_cv<ElementType>::type;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
-    using pointer = element_type*;
-    using const_pointer = const element_type*;
-    using reference = element_type&;
-    using const_reference = const element_type&;
-    using iterator = pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-
-    static constexpr size_type extent = Extent;
-
-    // [span.cons], span constructors, copy, assignment, and destructor
-    template <
-        std::size_t E = Extent,
-        typename std::enable_if<(E == dynamic_extent || E <= 0), int>::type = 0>
-    constexpr span() noexcept
-    {}
-
-    constexpr span(pointer ptr, size_type count)
-        : storage_(ptr, count)
-    {
-        assert(extent == dynamic_extent || count == extent);
-    }
-
-    constexpr span(pointer first_elem, pointer last_elem)
-        : storage_(first_elem, last_elem - first_elem)
-    {
-        assert(extent == dynamic_extent ||
-                        last_elem - first_elem ==
-                            static_cast<std::ptrdiff_t>(extent));
-    }
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          element_type (&)[N], ElementType>::value,
-                  int>::type = 0>
-    constexpr span(element_type (&arr)[N]) noexcept : storage_(arr, N)
-    {}
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          std::array<value_type, N>&, ElementType>::value,
-                  int>::type = 0>
-    constexpr span(std::array<value_type, N>& arr) noexcept
-        : storage_(arr.data(), N)
-    {}
-
-    template <std::size_t N, std::size_t E = Extent,
-              typename std::enable_if<
-                  (E == dynamic_extent || N == E) &&
-                      detail::is_container_element_type_compatible<
-                          const std::array<value_type, N>&, ElementType>::value,
-                  int>::type = 0>
-    constexpr span(const std::array<value_type, N>& arr) noexcept
-        : storage_(arr.data(), N)
-    {}
-
-    template <
-        typename Container, std::size_t E = Extent,
-        typename std::enable_if<
-            E == dynamic_extent && detail::is_container<Container>::value &&
-                detail::is_container_element_type_compatible<
-                    Container&, ElementType>::value,
-            int>::type = 0>
-    constexpr span(Container& cont)
-        : storage_(std::data(cont), std::size(cont))
-    {}
-
-    template <
-        typename Container, std::size_t E = Extent,
-        typename std::enable_if<
-            E == dynamic_extent && detail::is_container<Container>::value &&
-                detail::is_container_element_type_compatible<
-                    const Container&, ElementType>::value,
-            int>::type = 0>
-    constexpr span(const Container& cont)
-        : storage_(std::data(cont), std::size(cont))
-    {}
-
-    constexpr span(const span& other) noexcept = default;
-
-    template <typename OtherElementType, std::size_t OtherExtent,
-              typename std::enable_if<
-                  (Extent == OtherExtent || Extent == dynamic_extent) &&
-                      std::is_convertible<OtherElementType (*)[],
-                                          ElementType (*)[]>::value,
-                  int>::type = 0>
-    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
-        : storage_(other.data(), other.size())
-    {}
-
-#ifdef __cpp_lib_span
-    constexpr span(std::span<ElementType> other) noexcept
-        : storage_(other.data(), other.size())
-    {}
-#endif
-
-    ~span() noexcept = default;
-
-    constexpr span&
-    operator=(const span& other) noexcept = default;
-
-    // [span.sub], span subviews
-    template <std::size_t Count>
-    constexpr span<element_type, Count> first() const
-    {
-        assert(Count <= size());
-        return {data(), Count};
-    }
-
-    template <std::size_t Count>
-    constexpr span<element_type, Count> last() const
-    {
-        assert(Count <= size());
-        return {data() + (size() - Count), Count};
-    }
-
-    template <std::size_t Offset, std::size_t Count = dynamic_extent>
-    using subspan_return_t =
-        span<ElementType, Count != dynamic_extent
-                              ? Count
-                              : (Extent != dynamic_extent ? Extent - Offset
-                                                          : dynamic_extent)>;
-
-    template <std::size_t Offset, std::size_t Count = dynamic_extent>
-    constexpr subspan_return_t<Offset, Count> subspan() const
-    {
-        assert(Offset <= size() &&
-                        (Count == dynamic_extent || Offset + Count <= size()));
-        return {data() + Offset,
-                Count != dynamic_extent ? Count : size() - Offset};
-    }
-
-    constexpr span<element_type, dynamic_extent>
-    first(size_type count) const
-    {
-        assert(count <= size());
-        return {data(), count};
-    }
-
-    constexpr span<element_type, dynamic_extent>
-    last(size_type count) const
-    {
-        assert(count <= size());
-        return {data() + (size() - count), count};
-    }
-
-    constexpr span<element_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const
-    {
-        assert(offset <= size() &&
-                        (count == dynamic_extent || offset + count <= size()));
-        return {data() + offset,
-                count == dynamic_extent ? size() - offset : count};
-    }
-
-    // [span.obs], span observers
-    constexpr size_type size() const noexcept { return storage_.size; }
-
-    constexpr size_type size_bytes() const noexcept
-    {
-        return size() * sizeof(element_type);
-    }
-
-    [[nodiscard]] constexpr bool empty() const noexcept
-    {
-        return size() == 0;
-    }
-
-    // [span.elem], span element access
-    constexpr reference operator[](size_type idx) const
-    {
-        assert(idx < size());
-        return *(data() + idx);
-    }
-
-    constexpr reference front() const
-    {
-        assert(!empty());
-        return *data();
-    }
-
-    constexpr reference back() const
-    {
-        assert(!empty());
-        return *(data() + (size() - 1));
-    }
-
-    constexpr pointer data() const noexcept { return storage_.ptr; }
-
-    // [span.iterators], span iterator support
-    constexpr iterator begin() const noexcept { return data(); }
-
-    constexpr iterator end() const noexcept { return data() + size(); }
-
-    constexpr reverse_iterator rbegin() const noexcept
-    {
-        return reverse_iterator(end());
-    }
-
-    constexpr reverse_iterator rend() const noexcept
-    {
-        return reverse_iterator(begin());
-    }
-
-#ifdef __cpp_lib_span
-    constexpr operator auto() const {
-      return std::span < ElementType,
-             (Extent == dynamic_extent)
-                 ? std::dynamic_extent
-                 : Extent > (storage_.ptr, storage_.size);
-    }
-#endif
-
-private:
-    storage_type storage_{};
-};
-
-/* Deduction Guides */
-template <class T, size_t N>
-span(T (&)[N])->span<T, N>;
-
-template <class T, size_t N>
-span(std::array<T, N>&)->span<T, N>;
-
-template <class T, size_t N>
-span(const std::array<T, N>&)->span<const T, N>;
-
-template <class Container>
-span(Container&)->span<typename Container::value_type>;
-
-template <class Container>
-span(const Container&)->span<const typename Container::value_type>;
-
-template <typename ElementType, std::size_t Extent>
-span<const std::byte, ((Extent == dynamic_extent) ? dynamic_extent
-                                             : sizeof(ElementType) * Extent)>
-as_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<const std::byte*>(s.data()), s.size_bytes()};
-}
-
-template <
-    class ElementType, size_t Extent,
-    typename std::enable_if<!std::is_const<ElementType>::value, int>::type = 0>
-span<std::byte, ((Extent == dynamic_extent) ? dynamic_extent
-                                       : sizeof(ElementType) * Extent)>
-as_writable_bytes(span<ElementType, Extent> s) noexcept
-{
-    return {reinterpret_cast<std::byte*>(s.data()), s.size_bytes()};
-}
-
-template <std::size_t N, typename E, std::size_t S>
-constexpr auto get(span<E, S> s) -> decltype(s[N])
-{
-    return s[N];
-}
-
-} // namespace wpi
-
-namespace std {
-
-template <typename ElementType, size_t Extent>
-class tuple_size<wpi::span<ElementType, Extent>>
-    : public integral_constant<size_t, Extent> {};
-
-template <typename ElementType>
-class tuple_size<wpi::span<
-    ElementType, wpi::dynamic_extent>>; // not defined
-
-template <size_t I, typename ElementType, size_t Extent>
-class tuple_element<I, wpi::span<ElementType, Extent>> {
-public:
-    static_assert(Extent != wpi::dynamic_extent &&
-                      I < Extent,
-                  "");
-    using type = ElementType;
-};
-
-} // end namespace std
-
-#endif // WPIUTIL_WPI_SPAN_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/include/wpi/spinlock.h b/wpiutil/src/main/native/include/wpi/spinlock.h
index 9e777fa..7128a18 100644
--- a/wpiutil/src/main/native/include/wpi/spinlock.h
+++ b/wpiutil/src/main/native/include/wpi/spinlock.h
@@ -9,7 +9,7 @@
 #include <mutex>
 #include <thread>
 
-#include "Compiler.h"
+#include "wpi/Compiler.h"
 
 namespace wpi {
 
diff --git a/wpiutil/src/main/native/include/wpi/static_circular_buffer.h b/wpiutil/src/main/native/include/wpi/static_circular_buffer.h
index 8cbf3fe..76498a1 100644
--- a/wpiutil/src/main/native/include/wpi/static_circular_buffer.h
+++ b/wpiutil/src/main/native/include/wpi/static_circular_buffer.h
@@ -38,10 +38,7 @@
       ++(*this);
       return retval;
     }
-    bool operator==(const iterator& other) const {
-      return m_buffer == other.m_buffer && m_index == other.m_index;
-    }
-    bool operator!=(const iterator& other) const { return !(*this == other); }
+    bool operator==(const iterator&) const = default;
     reference operator*() { return (*m_buffer)[m_index]; }
 
    private:
@@ -69,12 +66,7 @@
       ++(*this);
       return retval;
     }
-    bool operator==(const const_iterator& other) const {
-      return m_buffer == other.m_buffer && m_index == other.m_index;
-    }
-    bool operator!=(const const_iterator& other) const {
-      return !(*this == other);
-    }
+    bool operator==(const const_iterator&) const = default;
     const_reference operator*() const { return (*m_buffer)[m_index]; }
 
    private:
diff --git a/wpiutil/src/main/native/include/wpi/type_traits.h b/wpiutil/src/main/native/include/wpi/type_traits.h
deleted file mode 100644
index 5d35ee1..0000000
--- a/wpiutil/src/main/native/include/wpi/type_traits.h
+++ /dev/null
@@ -1,125 +0,0 @@
-//===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides useful additions to the standard type_traits library.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef WPIUTIL_WPI_TYPE_TRAITS_H
-#define WPIUTIL_WPI_TYPE_TRAITS_H
-
-#include "wpi/Compiler.h"
-#include <type_traits>
-#include <utility>
-
-#ifndef __has_feature
-#define WPI_DEFINED_HAS_FEATURE
-#define __has_feature(x) 0
-#endif
-
-namespace wpi {
-
-/// isPodLike - This is a type trait that is used to determine whether a given
-/// type can be copied around with memcpy instead of running ctors etc.
-template <typename T>
-struct isPodLike {
-  // std::is_trivially_copyable is available in libc++ with clang, libstdc++
-  // that comes with GCC 5.
-#if (__has_feature(is_trivially_copyable) && defined(_LIBCPP_VERSION)) ||      \
-    (defined(__GNUC__) && __GNUC__ >= 5)
-  // If the compiler supports the is_trivially_copyable trait use it, as it
-  // matches the definition of isPodLike closely.
-  static const bool value = std::is_trivially_copyable<T>::value;
-#elif __has_feature(is_trivially_copyable)
-  // Use the internal name if the compiler supports is_trivially_copyable but we
-  // don't know if the standard library does. This is the case for clang in
-  // conjunction with libstdc++ from GCC 4.x.
-  static const bool value = __is_trivially_copyable(T);
-#else
-  // If we don't know anything else, we can (at least) assume that all non-class
-  // types are PODs.
-  static const bool value = !std::is_class<T>::value;
-#endif
-};
-
-// std::pair's are pod-like if their elements are.
-template<typename T, typename U>
-struct isPodLike<std::pair<T, U>> {
-  static const bool value = isPodLike<T>::value && isPodLike<U>::value;
-};
-
-/// Metafunction that determines whether the given type is either an
-/// integral type or an enumeration type, including enum classes.
-///
-/// Note that this accepts potentially more integral types than is_integral
-/// because it is based on being implicitly convertible to an integral type.
-/// Also note that enum classes aren't implicitly convertible to integral types,
-/// the value may therefore need to be explicitly converted before being used.
-template <typename T> class is_integral_or_enum {
-  using UnderlyingT = typename std::remove_reference<T>::type;
-
-public:
-  static const bool value =
-      !std::is_class<UnderlyingT>::value && // Filter conversion operators.
-      !std::is_pointer<UnderlyingT>::value &&
-      !std::is_floating_point<UnderlyingT>::value &&
-      (std::is_enum<UnderlyingT>::value ||
-       std::is_convertible<UnderlyingT, unsigned long long>::value);
-};
-
-/// If T is a pointer, just return it. If it is not, return T&.
-template<typename T, typename Enable = void>
-struct add_lvalue_reference_if_not_pointer { using type = T &; };
-
-template <typename T>
-struct add_lvalue_reference_if_not_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = T;
-};
-
-/// If T is a pointer to X, return a pointer to const X. If it is not,
-/// return const T.
-template<typename T, typename Enable = void>
-struct add_const_past_pointer { using type = const T; };
-
-template <typename T>
-struct add_const_past_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = const typename std::remove_pointer<T>::type *;
-};
-
-template <typename T, typename Enable = void>
-struct const_pointer_or_const_ref {
-  using type = const T &;
-};
-template <typename T>
-struct const_pointer_or_const_ref<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = typename add_const_past_pointer<T>::type;
-};
-
-} // namespace wpi
-
-// If the compiler supports detecting whether a class is final, define
-// an LLVM_IS_FINAL macro. If it cannot be defined properly, this
-// macro will be left undefined.
-#ifndef LLVM_IS_FINAL
-#if __cplusplus >= 201402L || defined(_MSC_VER)
-#define LLVM_IS_FINAL(Ty) std::is_final<Ty>()
-#elif __has_feature(is_final) || LLVM_GNUC_PREREQ(4, 7, 0)
-#define LLVM_IS_FINAL(Ty) __is_final(Ty)
-#endif
-#endif
-
-#ifdef WPI_DEFINED_HAS_FEATURE
-#undef __has_feature
-#undef WPI_DEFINED_HAS_FEATURE
-#endif
-
-#endif // LLVM_SUPPORT_TYPE_TRAITS_H
diff --git a/wpiutil/src/main/native/include/wpi/uv/Async.h b/wpiutil/src/main/native/include/wpi/uv/Async.h
deleted file mode 100644
index 49f3dde..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Async.h
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_ASYNC_H_
-#define WPIUTIL_WPI_UV_ASYNC_H_
-
-#include <uv.h>
-
-#include <memory>
-#include <thread>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#include "wpi/Signal.h"
-#include "wpi/mutex.h"
-#include "wpi/uv/Handle.h"
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-/**
- * Async handle.
- * Async handles allow the user to "wakeup" the event loop and have a signal
- * generated from another thread.
- *
- * Data may be passed into the callback called on the event loop by using
- * template parameters.  If data parameters are used, the async callback will
- * be called once for every call to Send().  If no data parameters are used,
- * the async callback may or may not be called for every call to Send() (e.g.
- * the calls may be coaleasced).
- */
-template <typename... T>
-class Async final : public HandleImpl<Async<T...>, uv_async_t> {
-  struct private_init {};
-
- public:
-  Async(const std::shared_ptr<Loop>& loop, const private_init&)
-      : m_loop{loop} {}
-  ~Async() noexcept override {
-    if (auto loop = m_loop.lock()) {
-      this->Close();
-    } else {
-      this->ForceClosed();
-    }
-  }
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Async> Create(Loop& loop) {
-    return Create(loop.shared_from_this());
-  }
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Async> Create(const std::shared_ptr<Loop>& loop) {
-    auto h = std::make_shared<Async>(loop, private_init{});
-    int err =
-        uv_async_init(loop->GetRaw(), h->GetRaw(), [](uv_async_t* handle) {
-          auto& h = *static_cast<Async*>(handle->data);
-          std::scoped_lock lock(h.m_mutex);
-          for (auto&& v : h.m_data) {
-            std::apply(h.wakeup, v);
-          }
-          h.m_data.clear();
-        });
-    if (err < 0) {
-      loop->ReportError(err);
-      return nullptr;
-    }
-    h->Keep();
-    return h;
-  }
-
-  /**
-   * Wakeup the event loop and emit the event.
-   *
-   * It’s safe to call this function from any thread including the loop thread.
-   * An async event will be emitted on the loop thread.
-   */
-  template <typename... U>
-  void Send(U&&... u) {
-    auto loop = m_loop.lock();
-    if (loop && loop->GetThreadId() == std::this_thread::get_id()) {
-      // called from within the loop, just call the function directly
-      wakeup(std::forward<U>(u)...);
-      return;
-    }
-
-    {
-      std::scoped_lock lock(m_mutex);
-      m_data.emplace_back(std::forward_as_tuple(std::forward<U>(u)...));
-    }
-    if (loop) {
-      this->Invoke(&uv_async_send, this->GetRaw());
-    }
-  }
-
-  /**
-   * Signal generated (on event loop thread) when the async event occurs.
-   */
-  sig::Signal<T...> wakeup;
-
- private:
-  wpi::mutex m_mutex;
-  std::vector<std::tuple<T...>> m_data;
-  std::weak_ptr<Loop> m_loop;
-};
-
-/**
- * Async specialization for no data parameters.  The async callback may or may
- * not be called for every call to Send() (e.g. the calls may be coaleasced).
- */
-template <>
-class Async<> final : public HandleImpl<Async<>, uv_async_t> {
-  struct private_init {};
-
- public:
-  Async(const std::shared_ptr<Loop>& loop, const private_init&)
-      : m_loop(loop) {}
-  ~Async() noexcept override;
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Async> Create(Loop& loop) {
-    return Create(loop.shared_from_this());
-  }
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Async> Create(const std::shared_ptr<Loop>& loop);
-
-  /**
-   * Wakeup the event loop and emit the event.
-   *
-   * It’s safe to call this function from any thread.
-   * An async event will be emitted on the loop thread.
-   */
-  void Send() {
-    if (auto loop = m_loop.lock()) {
-      if (loop->GetThreadId() == std::this_thread::get_id()) {
-        // called from within the loop, just call the function directly
-        wakeup();
-      } else {
-        Invoke(&uv_async_send, GetRaw());
-      }
-    }
-  }
-
-  /**
-   * Signal generated (on event loop thread) when the async event occurs.
-   */
-  sig::Signal<> wakeup;
-
- private:
-  std::weak_ptr<Loop> m_loop;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_ASYNC_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/AsyncFunction.h b/wpiutil/src/main/native/include/wpi/uv/AsyncFunction.h
deleted file mode 100644
index fa4eb90..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/AsyncFunction.h
+++ /dev/null
@@ -1,167 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_ASYNCFUNCTION_H_
-#define WPIUTIL_WPI_UV_ASYNCFUNCTION_H_
-
-#include <stdint.h>
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <thread>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#include "wpi/future.h"
-#include "wpi/mutex.h"
-#include "wpi/uv/Handle.h"
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-template <typename T>
-class AsyncFunction;
-
-/**
- * Function async handle.
- * Async handles allow the user to "wakeup" the event loop and have a function
- * called from another thread that returns a result to the calling thread.
- */
-template <typename R, typename... T>
-class AsyncFunction<R(T...)> final
-    : public HandleImpl<AsyncFunction<R(T...)>, uv_async_t> {
-  struct private_init {};
-
- public:
-  AsyncFunction(const std::shared_ptr<Loop>& loop,
-                std::function<void(promise<R>, T...)> func, const private_init&)
-      : wakeup{std::move(func)}, m_loop{loop} {}
-  ~AsyncFunction() noexcept override {
-    if (auto loop = m_loop.lock()) {
-      this->Close();
-    } else {
-      this->ForceClosed();
-    }
-  }
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param func wakeup function to be called (sets wakeup value); the function
-   *             needs to return void, and its first parameter is the promise
-   *             for the result.  If no value is set on the promise by the
-   *             wakeup function, a default-constructed value is "returned".
-   */
-  static std::shared_ptr<AsyncFunction> Create(
-      Loop& loop, std::function<void(promise<R>, T...)> func = nullptr) {
-    return Create(loop.shared_from_this(), std::move(func));
-  }
-
-  /**
-   * Create an async handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param func wakeup function to be called (sets wakeup value); the function
-   *             needs to return void, and its first parameter is the promise
-   *             for the result.  If no value is set on the promise by the
-   *             wakeup function, a default-constructed value is "returned".
-   */
-  static std::shared_ptr<AsyncFunction> Create(
-      const std::shared_ptr<Loop>& loop,
-      std::function<void(promise<R>, T...)> func = nullptr) {
-    auto h =
-        std::make_shared<AsyncFunction>(loop, std::move(func), private_init{});
-    int err =
-        uv_async_init(loop->GetRaw(), h->GetRaw(), [](uv_async_t* handle) {
-          auto& h = *static_cast<AsyncFunction*>(handle->data);
-          std::unique_lock lock(h.m_mutex);
-
-          if (!h.m_params.empty()) {
-            // for each set of parameters in the input queue, call the wakeup
-            // function and put the result in the output queue if the caller is
-            // waiting for it
-            for (auto&& v : h.m_params) {
-              auto p = h.m_promises.CreatePromise(v.first);
-              if (h.wakeup) {
-                std::apply(h.wakeup,
-                           std::tuple_cat(std::make_tuple(std::move(p)),
-                                          std::move(v.second)));
-              }
-            }
-            h.m_params.clear();
-            // wake up any threads that might be waiting for the result
-            lock.unlock();
-            h.m_promises.Notify();
-          }
-        });
-    if (err < 0) {
-      loop->ReportError(err);
-      return nullptr;
-    }
-    h->Keep();
-    return h;
-  }
-
-  /**
-   * Wakeup the event loop, call the async function, and return a future for
-   * the result.
-   *
-   * It’s safe to call this function from any thread including the loop thread.
-   * The async function will be called on the loop thread.
-   *
-   * The future will return a default-constructed result if this handle is
-   * destroyed while waiting for a result.
-   */
-  template <typename... U>
-  future<R> Call(U&&... u) {
-    // create the future
-    uint64_t req = m_promises.CreateRequest();
-
-    auto loop = m_loop.lock();
-    if (loop && loop->GetThreadId() == std::this_thread::get_id()) {
-      // called from within the loop, just call the function directly
-      wakeup(m_promises.CreatePromise(req), std::forward<U>(u)...);
-      return m_promises.CreateFuture(req);
-    }
-
-    // add the parameters to the input queue
-    {
-      std::scoped_lock lock(m_mutex);
-      m_params.emplace_back(std::piecewise_construct,
-                            std::forward_as_tuple(req),
-                            std::forward_as_tuple(std::forward<U>(u)...));
-    }
-
-    // signal the loop
-    if (loop) {
-      this->Invoke(&uv_async_send, this->GetRaw());
-    }
-
-    // return future
-    return m_promises.CreateFuture(req);
-  }
-
-  template <typename... U>
-  future<R> operator()(U&&... u) {
-    return Call(std::forward<U>(u)...);
-  }
-
-  /**
-   * Function called (on event loop thread) when the async is called.
-   */
-  std::function<void(promise<R>, T...)> wakeup;
-
- private:
-  wpi::mutex m_mutex;
-  std::vector<std::pair<uint64_t, std::tuple<T...>>> m_params;
-  PromiseFactory<R> m_promises;
-  std::weak_ptr<Loop> m_loop;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_ASYNCFUNCTION_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Buffer.h b/wpiutil/src/main/native/include/wpi/uv/Buffer.h
deleted file mode 100644
index 5126841..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Buffer.h
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_BUFFER_H_
-#define WPIUTIL_WPI_UV_BUFFER_H_
-
-#include <uv.h>
-
-#include <cstring>
-#include <initializer_list>
-#include <string_view>
-#include <utility>
-
-#include "wpi/SmallVector.h"
-#include "wpi/span.h"
-
-namespace wpi::uv {
-
-/**
- * Data buffer.  Convenience wrapper around uv_buf_t.
- */
-class Buffer : public uv_buf_t {
- public:
-  Buffer() {
-    base = nullptr;
-    len = 0;
-  }
-  /*implicit*/ Buffer(const uv_buf_t& oth) {  // NOLINT
-    base = oth.base;
-    len = oth.len;
-  }
-  /*implicit*/ Buffer(std::string_view str)  // NOLINT
-      : Buffer{str.data(), str.size()} {}
-  /*implicit*/ Buffer(span<const uint8_t> arr)  // NOLINT
-      : Buffer{reinterpret_cast<const char*>(arr.data()), arr.size()} {}
-  Buffer(char* base_, size_t len_) {
-    base = base_;
-    len = static_cast<decltype(len)>(len_);
-  }
-  Buffer(const char* base_, size_t len_) {
-    base = const_cast<char*>(base_);
-    len = static_cast<decltype(len)>(len_);
-  }
-
-  span<const char> data() const { return {base, len}; }
-  span<char> data() { return {base, len}; }
-
-  operator span<const char>() const { return data(); }  // NOLINT
-  operator span<char>() { return data(); }              // NOLINT
-
-  static Buffer Allocate(size_t size) { return Buffer{new char[size], size}; }
-
-  static Buffer Dup(std::string_view in) {
-    Buffer buf = Allocate(in.size());
-    std::memcpy(buf.base, in.data(), in.size());
-    return buf;
-  }
-
-  static Buffer Dup(span<const uint8_t> in) {
-    Buffer buf = Allocate(in.size());
-    std::memcpy(buf.base, in.begin(), in.size());
-    return buf;
-  }
-
-  Buffer Dup() const {
-    Buffer buf = Allocate(len);
-    std::memcpy(buf.base, base, len);
-    return buf;
-  }
-
-  void Deallocate() {
-    delete[] base;
-    base = nullptr;
-    len = 0;
-  }
-
-  Buffer Move() {
-    Buffer buf = *this;
-    base = nullptr;
-    len = 0;
-    return buf;
-  }
-
-  friend void swap(Buffer& a, Buffer& b) {
-    using std::swap;
-    swap(a.base, b.base);
-    swap(a.len, b.len);
-  }
-};
-
-/**
- * A simple pool allocator for Buffers.
- * Buffers are allocated individually but are reused rather than returned
- * to the heap.
- * @tparam DEPTH depth of pool
- */
-template <size_t DEPTH = 4>
-class SimpleBufferPool {
- public:
-  /**
-   * Constructor.
-   * @param size Size of each buffer to allocate.
-   */
-  explicit SimpleBufferPool(size_t size = 4096) : m_size{size} {}
-  ~SimpleBufferPool() { Clear(); }
-
-  SimpleBufferPool(const SimpleBufferPool& other) = delete;
-  SimpleBufferPool& operator=(const SimpleBufferPool& other) = delete;
-
-  /**
-   * Allocate a buffer.
-   */
-  Buffer Allocate() {
-    if (m_pool.empty()) {
-      return Buffer::Allocate(m_size);
-    }
-    auto buf = m_pool.back();
-    m_pool.pop_back();
-    buf.len = m_size;
-    return buf;
-  }
-
-  /**
-   * Allocate a buffer.
-   */
-  Buffer operator()() { return Allocate(); }
-
-  /**
-   * Release allocated buffers back into the pool.
-   * This is NOT safe to use with arbitrary buffers unless they were
-   * allocated with the same size as the buffer pool allocation size.
-   */
-  void Release(span<Buffer> bufs) {
-    for (auto& buf : bufs) {
-      m_pool.emplace_back(buf.Move());
-    }
-  }
-
-  /**
-   * Clear the pool, releasing all buffers.
-   */
-  void Clear() {
-    for (auto& buf : m_pool) {
-      buf.Deallocate();
-    }
-    m_pool.clear();
-  }
-
-  /**
-   * Get number of buffers left in the pool before a new buffer will be
-   * allocated from the heap.
-   */
-  size_t Remaining() const { return m_pool.size(); }
-
- private:
-  SmallVector<Buffer, DEPTH> m_pool;
-  size_t m_size;  // NOLINT
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_BUFFER_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Check.h b/wpiutil/src/main/native/include/wpi/uv/Check.h
deleted file mode 100644
index 7555452..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Check.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_CHECK_H_
-#define WPIUTIL_WPI_UV_CHECK_H_
-
-#include <uv.h>
-
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Check handle.
- * Check handles will generate a signal once per loop iteration, right
- * after polling for I/O.
- */
-class Check final : public HandleImpl<Check, uv_check_t> {
-  struct private_init {};
-
- public:
-  explicit Check(const private_init&) {}
-  ~Check() noexcept override = default;
-
-  /**
-   * Create a check handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Check> Create(Loop& loop);
-
-  /**
-   * Create a check handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Check> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Start the handle.
-   */
-  void Start();
-
-  /**
-   * Stop the handle.  The signal will no longer be generated.
-   */
-  void Stop() { Invoke(&uv_check_stop, GetRaw()); }
-
-  /**
-   * Signal generated once per loop iteration after polling for I/O.
-   */
-  sig::Signal<> check;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_CHECK_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Error.h b/wpiutil/src/main/native/include/wpi/uv/Error.h
deleted file mode 100644
index 1e717a4..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Error.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_ERROR_H_
-#define WPIUTIL_WPI_UV_ERROR_H_
-
-#include <uv.h>
-
-namespace wpi::uv {
-
-/**
- * Error code.
- */
-class Error {
- public:
-  Error() = default;
-  explicit Error(int err) : m_err(err) {}
-
-  /**
-   * Boolean conversion.  Returns true if error, false if ok.
-   */
-  explicit operator bool() const { return m_err < 0; }
-
-  /**
-   * Returns the error code.
-   */
-  int code() const { return m_err; }
-
-  /**
-   * Returns the error message.
-   */
-  const char* str() const { return uv_strerror(m_err); }
-
-  /**
-   * Returns the error name.
-   */
-  const char* name() const { return uv_err_name(m_err); }
-
- private:
-  int m_err{UV_UNKNOWN};
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_ERROR_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/FsEvent.h b/wpiutil/src/main/native/include/wpi/uv/FsEvent.h
deleted file mode 100644
index 0ed2dcb..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/FsEvent.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_FSEVENT_H_
-#define WPIUTIL_WPI_UV_FSEVENT_H_
-
-#include <uv.h>
-
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Filesystem Event handle.
- */
-class FsEvent final : public HandleImpl<FsEvent, uv_fs_event_t> {
-  struct private_init {};
-
- public:
-  explicit FsEvent(const private_init&) {}
-  ~FsEvent() noexcept override = default;
-
-  /**
-   * Create a filesystem event handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<FsEvent> Create(Loop& loop);
-
-  /**
-   * Create a filesystem event handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<FsEvent> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Start watching the specified path for changes.
-   *
-   * @param path Path to watch for changes
-   * @param events Bitmask of event flags.  Only UV_FS_EVENT_RECURSIVE is
-   *               supported (and only on OSX and Windows).
-   */
-  void Start(std::string_view path, unsigned int flags = 0);
-
-  /**
-   * Stop watching for changes.
-   */
-  void Stop() { Invoke(&uv_fs_event_stop, GetRaw()); }
-
-  /**
-   * Get the path being monitored.  Signals error and returns empty string if
-   * an error occurs.
-   * @return Monitored path.
-   */
-  std::string GetPath();
-
-  /**
-   * Signal generated when a filesystem change occurs.  The first parameter
-   * is the filename (if a directory was passed to Start(), the filename is
-   * relative to that directory).  The second parameter is an ORed mask of
-   * UV_RENAME and UV_CHANGE.
-   */
-  sig::Signal<const char*, int> fsEvent;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_FSEVENT_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/GetAddrInfo.h b/wpiutil/src/main/native/include/wpi/uv/GetAddrInfo.h
deleted file mode 100644
index 18d4f32..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/GetAddrInfo.h
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_GETADDRINFO_H_
-#define WPIUTIL_WPI_UV_GETADDRINFO_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Request.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * GetAddrInfo request.
- * For use with `GetAddrInfo()` function family.
- */
-class GetAddrInfoReq : public RequestImpl<GetAddrInfoReq, uv_getaddrinfo_t> {
- public:
-  GetAddrInfoReq();
-
-  Loop& GetLoop() const { return *static_cast<Loop*>(GetRaw()->loop->data); }
-
-  /**
-   * Resolved lookup signal.
-   * Parameter is resolved address info.
-   */
-  sig::Signal<const addrinfo&> resolved;
-};
-
-/**
- * Asynchronous getaddrinfo(3).  HandleResolvedAddress() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * Either node or service may be empty but not both.
- *
- * @param loop Event loop
- * @param req request
- * @param node Either a numerical network address or a network hostname.
- * @param service Either a service name or a port number as a string.
- * @param hints Optional `addrinfo` data structure with additional address
- *              type constraints.
- */
-void GetAddrInfo(Loop& loop, const std::shared_ptr<GetAddrInfoReq>& req,
-                 std::string_view node, std::string_view service = {},
-                 const addrinfo* hints = nullptr);
-
-/**
- * Asynchronous getaddrinfo(3).  HandleResolvedAddress() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * Either node or service may be empty but not both.
- *
- * @param loop Event loop
- * @param req request
- * @param node Either a numerical network address or a network hostname.
- * @param service Either a service name or a port number as a string.
- * @param hints Optional `addrinfo` data structure with additional address
- *              type constraints.
- */
-inline void GetAddrInfo(const std::shared_ptr<Loop>& loop,
-                        const std::shared_ptr<GetAddrInfoReq>& req,
-                        std::string_view node, std::string_view service = {},
-                        const addrinfo* hints = nullptr) {
-  GetAddrInfo(*loop, req, node, service, hints);
-}
-
-/**
- * Asynchronous getaddrinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.  This is a convenience
- * wrapper.
- *
- * Either node or service may be empty but not both.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param node Either a numerical network address or a network hostname.
- * @param service Either a service name or a port number as a string.
- * @param hints Optional `addrinfo` data structure with additional address
- *              type constraints.
- */
-void GetAddrInfo(Loop& loop, std::function<void(const addrinfo&)> callback,
-                 std::string_view node, std::string_view service = {},
-                 const addrinfo* hints = nullptr);
-
-/**
- * Asynchronous getaddrinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.  This is a convenience
- * wrapper.
- *
- * Either node or service may be empty but not both.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param node Either a numerical network address or a network hostname.
- * @param service Either a service name or a port number as a string.
- * @param hints Optional `addrinfo` data structure with additional address
- *              type constraints.
- */
-inline void GetAddrInfo(const std::shared_ptr<Loop>& loop,
-                        std::function<void(const addrinfo&)> callback,
-                        std::string_view node, std::string_view service = {},
-                        const addrinfo* hints = nullptr) {
-  GetAddrInfo(*loop, std::move(callback), node, service, hints);
-}
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_GETADDRINFO_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/GetNameInfo.h b/wpiutil/src/main/native/include/wpi/uv/GetNameInfo.h
deleted file mode 100644
index d35dd95..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/GetNameInfo.h
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_GETNAMEINFO_H_
-#define WPIUTIL_WPI_UV_GETNAMEINFO_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Request.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * GetNameInfo request.
- * For use with `GetNameInfo()` function family.
- */
-class GetNameInfoReq : public RequestImpl<GetNameInfoReq, uv_getnameinfo_t> {
- public:
-  GetNameInfoReq();
-
-  Loop& GetLoop() const { return *static_cast<Loop*>(GetRaw()->loop->data); }
-
-  /**
-   * Resolved lookup signal.
-   * Parameters are hostname and service.
-   */
-  sig::Signal<const char*, const char*> resolved;
-};
-
-/**
- * Asynchronous getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                 const sockaddr& addr, int flags = 0);
-
-/**
- * Asynchronous getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-inline void GetNameInfo(const std::shared_ptr<Loop>& loop,
-                        const std::shared_ptr<GetNameInfoReq>& req,
-                        const sockaddr& addr, int flags = 0) {
-  GetNameInfo(*loop, req, addr, flags);
-}
-
-/**
- * Asynchronous getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo(Loop& loop,
-                 std::function<void(const char*, const char*)> callback,
-                 const sockaddr& addr, int flags = 0);
-
-/**
- * Asynchronous getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- * @return Connection object for the callback
- */
-inline void GetNameInfo(const std::shared_ptr<Loop>& loop,
-                        std::function<void(const char*, const char*)> callback,
-                        const sockaddr& addr, int flags = 0) {
-  GetNameInfo(*loop, std::move(callback), addr, flags);
-}
-
-/**
- * Asynchronous IPv4 getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param ip A valid IPv4 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo4(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                  std::string_view ip, unsigned int port, int flags = 0);
-
-/**
- * Asynchronous IPv4 getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param ip A valid IPv4 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-inline void GetNameInfo4(const std::shared_ptr<Loop>& loop,
-                         const std::shared_ptr<GetNameInfoReq>& req,
-                         std::string_view ip, unsigned int port,
-                         int flags = 0) {
-  return GetNameInfo4(*loop, req, ip, port, flags);
-}
-
-/**
- * Asynchronous IPv4 getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param ip A valid IPv4 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo4(Loop& loop,
-                  std::function<void(const char*, const char*)> callback,
-                  std::string_view ip, unsigned int port, int flags = 0);
-
-/**
- * Asynchronous IPv4 getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.  This is a convenience
- * wrapper.
- *
- * @param loop Event loop
- * @param ip A valid IPv4 address
- * @param port A valid port number
- * @param callback Callback function to call when resolution completes
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-inline void GetNameInfo4(const std::shared_ptr<Loop>& loop,
-                         std::function<void(const char*, const char*)> callback,
-                         std::string_view ip, unsigned int port,
-                         int flags = 0) {
-  return GetNameInfo4(*loop, std::move(callback), ip, port, flags);
-}
-
-/**
- * Asynchronous IPv6 getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param ip A valid IPv6 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo6(Loop& loop, const std::shared_ptr<GetNameInfoReq>& req,
-                  std::string_view ip, unsigned int port, int flags = 0);
-
-/**
- * Asynchronous IPv6 getnameinfo(3).  HandleResolvedName() is called on the
- * request when the resolution completes.  HandleError() is called on the
- * request if any errors occur.
- *
- * @param loop Event loop
- * @param req request
- * @param ip A valid IPv6 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-inline void GetNameInfo6(const std::shared_ptr<Loop>& loop,
-                         const std::shared_ptr<GetNameInfoReq>& req,
-                         std::string_view ip, unsigned int port,
-                         int flags = 0) {
-  GetNameInfo6(*loop, req, ip, port, flags);
-}
-
-/**
- * Asynchronous IPv6 getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.  This is a convenience
- * wrapper.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param ip A valid IPv6 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-void GetNameInfo6(Loop& loop,
-                  std::function<void(const char*, const char*)> callback,
-                  std::string_view ip, unsigned int port, int flags = 0);
-
-/**
- * Asynchronous IPv6 getnameinfo(3).  The callback is called when the resolution
- * completes, and errors are forwarded to the loop.  This is a convenience
- * wrapper.
- *
- * @param loop Event loop
- * @param callback Callback function to call when resolution completes
- * @param ip A valid IPv6 address
- * @param port A valid port number
- * @param flags Optional flags to modify the behavior of `getnameinfo`.
- */
-inline void GetNameInfo6(const std::shared_ptr<Loop>& loop,
-                         std::function<void(const char*, const char*)> callback,
-                         std::string_view ip, unsigned int port,
-                         int flags = 0) {
-  return GetNameInfo6(*loop, std::move(callback), ip, port, flags);
-}
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_GETNAMEINFO_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Handle.h b/wpiutil/src/main/native/include/wpi/uv/Handle.h
deleted file mode 100644
index b61cd81..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Handle.h
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_HANDLE_H_
-#define WPIUTIL_WPI_UV_HANDLE_H_
-
-#include <uv.h>
-
-#include <cstdlib>
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Buffer.h"
-#include "wpi/uv/Error.h"
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-/**
- * Handle.
- * Handles are not moveable or copyable and cannot be directly constructed.
- * This class provides shared_ptr ownership and shared_from_this.
- * Use the specific handle type Create() functions to create handles.
- */
-class Handle : public std::enable_shared_from_this<Handle> {
- public:
-  using Type = uv_handle_type;
-
-  Handle(const Handle&) = delete;
-  Handle(Handle&&) = delete;
-  Handle& operator=(const Handle&) = delete;
-  Handle& operator=(Handle&&) = delete;
-  virtual ~Handle() noexcept;
-
-  /**
-   * Get the type of the handle.
-   *
-   * A base handle offers no functionality to promote it to the actual handle
-   * type. By means of this function, the type of the underlying handle as
-   * specified by Type is made available.
-   *
-   * @return The actual type of the handle.
-   */
-  Type GetType() const noexcept { return m_uv_handle->type; }
-
-  /**
-   * Get the name of the type of the handle.  E.g. "pipe" for pipe handles.
-   */
-  std::string_view GetTypeName() const noexcept {
-    return uv_handle_type_name(m_uv_handle->type);
-  }
-
-  /**
-   * Get the loop where this handle runs.
-   *
-   * @return The loop.
-   */
-  std::shared_ptr<Loop> GetLoop() const noexcept {
-    return GetLoopRef().shared_from_this();
-  }
-
-  /**
-   * Get the loop where this handle runs.
-   *
-   * @return The loop.
-   */
-  Loop& GetLoopRef() const noexcept {
-    return *static_cast<Loop*>(m_uv_handle->loop->data);
-  }
-
-  /**
-   * Check if the handle is active.
-   *
-   * What _active_ means depends on the type of handle:
-   *
-   * * An AsyncHandle handle is always active and cannot be deactivated,
-   * except by closing it with uv_close().
-   * * A PipeHandle, TcpHandle, UDPHandle, etc. handle - basically any handle
-   * that deals with I/O - is active when it is doing something that involves
-   * I/O, like reading, writing, connecting, accepting new connections, etc.
-   * * A CheckHandle, IdleHandle, TimerHandle, etc. handle is active when it
-   * has been started with a call to `Start()`.
-   *
-   * Rule of thumb: if a handle of type `FooHandle` has a `Start()` member
-   * method, then it’s active from the moment that method is called. Likewise,
-   * `Stop()` deactivates the handle again.
-   *
-   * @return True if the handle is active, false otherwise.
-   */
-  bool IsActive() const noexcept { return uv_is_active(m_uv_handle) != 0; }
-
-  /**
-   * Check if a handle is closing or closed.
-   *
-   * This function should only be used between the initialization of the
-   * handle and the arrival of the close callback.
-   *
-   * @return True if the handle is closing or closed, false otherwise.
-   */
-  bool IsClosing() const noexcept {
-    return m_closed || uv_is_closing(m_uv_handle) != 0;
-  }
-
-  /**
-   * Request handle to be closed.
-   *
-   * This **must** be called on each handle before memory is released.
-   * In-progress requests are cancelled and this can result in error() being
-   * emitted.
-   *
-   * The handle will emit closed() when finished.
-   */
-  void Close() noexcept;
-
-  /**
-   * Set if the loop is closing.
-   *
-   * This is set during EventLoopRunner.Stop(), and can be used for other cases
-   * to indicate the loop should be closing. For instance for a uv_walk loop can
-   * use this to close existing handles.
-   *
-   * @param loopClosing true to set the loop currently in closing stages.
-   */
-  void SetLoopClosing(bool loopClosing) noexcept {
-    m_loopClosing = loopClosing;
-  }
-
-  /**
-   * Get the loop closing status.
-   *
-   * This can be used from closed() in order to tell if a closing loop is the
-   * reason for the close, or another reason.
-   *
-   * @return true if the loop is closing, otherwise false.
-   */
-  bool IsLoopClosing() const noexcept { return m_loopClosing; }
-
-  /**
-   * Reference the given handle.
-   *
-   * References are idempotent, that is, if a handle is already referenced
-   * calling this function again will have no effect.
-   */
-  void Reference() noexcept { uv_ref(m_uv_handle); }
-
-  /**
-   * Unreference the given handle.
-   *
-   * References are idempotent, that is, if a handle is not referenced calling
-   * this function again will have no effect.
-   */
-  void Unreference() noexcept { uv_unref(m_uv_handle); }
-
-  /**
-   * Check if the given handle is referenced.
-   * @return True if the handle is referenced, false otherwise.
-   */
-  bool HasReference() const noexcept { return uv_has_ref(m_uv_handle) != 0; }
-
-  /**
-   * Return the size of the underlying handle type.
-   * @return The size of the underlying handle type.
-   */
-  size_t RawSize() const noexcept { return uv_handle_size(m_uv_handle->type); }
-
-  /**
-   * Get the underlying handle data structure.
-   *
-   * @return The underlying handle data structure.
-   */
-  uv_handle_t* GetRawHandle() const noexcept { return m_uv_handle; }
-
-  /**
-   * Set the functions used for allocating and releasing buffers.  The size
-   * passed to the allocator function is a "suggested" size--it's just an
-   * indication, not related in any way to the pending data to be read.  The
-   * user is free to allocate the amount of memory they decide.  For example,
-   * applications with custom allocation schemes may decide to use a different
-   * size which matches the memory chunks they already have for other purposes.
-   *
-   * @warning Be very careful changing the allocator after the loop has started
-   * running; there are no interlocks between this and buffers currently in
-   * flight.
-   *
-   * @param alloc Allocation function
-   * @param dealloc Deallocation function
-   */
-  void SetBufferAllocator(std::function<Buffer(size_t)> alloc,
-                          std::function<void(Buffer&)> dealloc) {
-    m_allocBuf = std::move(alloc);
-    m_freeBuf = std::move(dealloc);
-  }
-
-  /**
-   * Free a buffer.  Uses the function provided to SetBufFree() or
-   * Buffer::Deallocate by default.
-   *
-   * @param buf The buffer
-   */
-  void FreeBuf(Buffer& buf) const noexcept { m_freeBuf(buf); }
-
-  /**
-   * Gets user-defined data.
-   * @return User-defined data if any, nullptr otherwise.
-   */
-  template <typename T = void>
-  std::shared_ptr<T> GetData() const {
-    return std::static_pointer_cast<T>(m_data);
-  }
-
-  /**
-   * Sets user-defined data.
-   * @param data User-defined arbitrary data.
-   */
-  void SetData(std::shared_ptr<void> data) { m_data = std::move(data); }
-
-  /**
-   * Error signal
-   */
-  sig::Signal<Error> error;
-
-  /**
-   * Closed signal
-   */
-  sig::Signal<> closed;
-
-  /**
-   * Report an error.
-   * @param err Error code
-   */
-  void ReportError(int err) const { error(Error(err)); }
-
- protected:
-  explicit Handle(uv_handle_t* uv_handle) : m_uv_handle{uv_handle} {
-    m_uv_handle->data = this;
-  }
-
-  void Keep() noexcept { m_self = shared_from_this(); }
-  void Release() noexcept { m_self.reset(); }
-  void ForceClosed() noexcept { m_closed = true; }
-
-  static void AllocBuf(uv_handle_t* handle, size_t size, uv_buf_t* buf);
-  static void DefaultFreeBuf(Buffer& buf);
-
-  template <typename F, typename... Args>
-  bool Invoke(F&& f, Args&&... args) const {
-    auto err = std::forward<F>(f)(std::forward<Args>(args)...);
-    if (err < 0) {
-      ReportError(err);
-    }
-    return err == 0;
-  }
-
- private:
-  std::shared_ptr<Handle> m_self;
-  uv_handle_t* m_uv_handle;
-  bool m_closed = false;
-  bool m_loopClosing = false;
-  std::function<Buffer(size_t)> m_allocBuf{&Buffer::Allocate};
-  std::function<void(Buffer&)> m_freeBuf{&DefaultFreeBuf};
-  std::shared_ptr<void> m_data;
-};
-
-/**
- * Handle.
- */
-template <typename T, typename U>
-class HandleImpl : public Handle {
- public:
-  std::shared_ptr<T> shared_from_this() {
-    return std::static_pointer_cast<T>(Handle::shared_from_this());
-  }
-
-  std::shared_ptr<const T> shared_from_this() const {
-    return std::static_pointer_cast<const T>(Handle::shared_from_this());
-  }
-
-  /**
-   * Get the underlying handle data structure.
-   *
-   * @return The underlying handle data structure.
-   */
-  U* GetRaw() const noexcept {
-    return reinterpret_cast<U*>(this->GetRawHandle());
-  }
-
- protected:
-  HandleImpl() : Handle{static_cast<uv_handle_t*>(std::malloc(sizeof(U)))} {}
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_HANDLE_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Idle.h b/wpiutil/src/main/native/include/wpi/uv/Idle.h
deleted file mode 100644
index 869d43d..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Idle.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_IDLE_H_
-#define WPIUTIL_WPI_UV_IDLE_H_
-
-#include <uv.h>
-
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Idle handle.
- *
- * Idle handles will generate a signal once per loop iteration, right
- * before the Prepare handles.
- *
- * The notable difference with Prepare handles is that when there are active
- * idle handles, the loop will perform a zero timeout poll instead of blocking
- * for I/O.
- *
- * @warning Despite the name, idle handles will signal every loop iteration,
- * not when the loop is actually "idle".  This also means they can easly become
- * CPU hogs.
- */
-class Idle final : public HandleImpl<Idle, uv_idle_t> {
-  struct private_init {};
-
- public:
-  explicit Idle(const private_init&) {}
-  ~Idle() noexcept override = default;
-
-  /**
-   * Create an idle handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Idle> Create(Loop& loop);
-
-  /**
-   * Create an idle handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Idle> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Start the handle.
-   */
-  void Start();
-
-  /**
-   * Stop the handle.  The signal will no longer be generated.
-   */
-  void Stop() { Invoke(&uv_idle_stop, GetRaw()); }
-
-  /**
-   * Signal generated once per loop iteration prior to Prepare signals.
-   */
-  sig::Signal<> idle;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_IDLE_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Loop.h b/wpiutil/src/main/native/include/wpi/uv/Loop.h
deleted file mode 100644
index 9693053..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Loop.h
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_LOOP_H_
-#define WPIUTIL_WPI_UV_LOOP_H_
-
-#include <uv.h>
-
-#include <atomic>
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <thread>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/function_ref.h"
-#include "wpi/uv/Error.h"
-
-namespace wpi::uv {
-
-class Handle;
-
-/**
- * Event loop.
- *
- * The event loop is the central part of uv functionality.  It takes care of
- * polling for I/O and scheduling signals to be generated based on different
- * sources of events.
- *
- * The event loop is not moveable, copyable, or directly constructible.  Use
- * Create() to create an event loop, or GetDefault() to get the default loop
- * if you know your program will only have a single one.
- */
-class Loop final : public std::enable_shared_from_this<Loop> {
-  struct private_init {};
-
- public:
-  using Time = std::chrono::duration<uint64_t, std::milli>;
-
-  enum Mode {
-    kDefault = UV_RUN_DEFAULT,
-    kOnce = UV_RUN_ONCE,
-    kNoWait = UV_RUN_NOWAIT
-  };
-
-  explicit Loop(const private_init&) noexcept;
-
-  Loop(const Loop&) = delete;
-  Loop& operator=(const Loop&) = delete;
-  Loop(Loop&& oth) = delete;
-  Loop& operator=(Loop&& oth) = delete;
-
-  ~Loop() noexcept;
-
-  /**
-   * Create a new event loop.  The created loop is not the default event loop.
-   *
-   * @return The newly created loop.  May return nullptr if a failure occurs.
-   */
-  static std::shared_ptr<Loop> Create();
-
-  /**
-   * Create the default event loop.  Only use this event loop if a single loop
-   * is needed for the entire application.
-   *
-   * @return The newly created loop.  May return nullptr if a failure occurs.
-   */
-  static std::shared_ptr<Loop> GetDefault();
-
-  /**
-   * Release all internal loop resources.
-   *
-   * Call this function only when the loop has finished executing and all open
-   * handles and requests have been closed, or the loop will emit an error.
-   *
-   * error() will be emitted in case of errors.
-   */
-  void Close();
-
-  /**
-   * Run the event loop.
-   *
-   * Available modes are:
-   *
-   * * `Loop::kDefault`: Run the event loop until there are no
-   *                     active and referenced handles or requests.
-   * * `Loop::kOnce`: Run a single event loop iteration. Note that this
-   *                  function blocksif there are no pending callbacks.
-   * * `Loop::kNoWait`: Run a single event loop iteration, but don't block
-   *                    if there are no pending callbacks.
-   *
-   * @return True when done, false in all other cases.
-   */
-  bool Run(Mode mode = kDefault) {
-    m_tid = std::this_thread::get_id();
-    int rv = uv_run(m_loop, static_cast<uv_run_mode>(static_cast<int>(mode)));
-    m_tid = std::thread::id{};
-    return rv == 0;
-  }
-
-  /**
-   * Check if there are active resources.
-   *
-   * @return True if there are active resources in the loop.
-   */
-  bool IsAlive() const noexcept { return uv_loop_alive(m_loop) != 0; }
-
-  /**
-   * Stop the event loop.
-   *
-   * This will cause Run() to end as soon as possible.
-   * This will happen not sooner than the next loop iteration.
-   * If this function was called before blocking for I/O, the loop won’t block
-   * for I/O on this iteration.
-   */
-  void Stop() noexcept { uv_stop(m_loop); }
-
-  /**
-   * Get backend file descriptor.
-   *
-   * Only kqueue, epoll and event ports are supported.
-   * This can be used in conjunction with `run(Loop::kNoWait)` to poll
-   * in one thread and run the event loop’s callbacks in another.
-   *
-   * @return The backend file descriptor.
-   */
-  int GetDescriptor() const noexcept { return uv_backend_fd(m_loop); }
-
-  /**
-   * Get the poll timeout.
-   *
-   * @return A `std::pair` composed of a boolean value that is true in case of
-   * valid timeout, false otherwise, and the timeout
-   * (`std::chrono::duration<uint64_t, std::milli>`).
-   */
-  std::pair<bool, Time> GetTimeout() const noexcept {
-    auto to = uv_backend_timeout(m_loop);
-    return std::make_pair(to == -1, Time{to});
-  }
-
-  /**
-   * Return the current timestamp in milliseconds.
-   *
-   * The timestamp is cached at the start of the event loop tick.
-   * The timestamp increases monotonically from some arbitrary point in
-   * time.
-   * Don’t make assumptions about the starting point, you will only get
-   * disappointed.
-   *
-   * @return The current timestamp in milliseconds (actual type is
-   * `std::chrono::duration<uint64_t, std::milli>`).
-   */
-  Time Now() const noexcept { return Time{uv_now(m_loop)}; }
-
-  /**
-   * Update the event loop’s concept of _now_.
-   *
-   * The current time is cached at the start of the event loop tick in order
-   * to reduce the number of time-related system calls.
-   * You won’t normally need to call this function unless you have callbacks
-   * that block the event loop for longer periods of time, where _longer_ is
-   * somewhat subjective but probably on the order of a millisecond or more.
-   */
-  void UpdateTime() noexcept { uv_update_time(m_loop); }
-
-  /**
-   * Walk the list of handles.
-   *
-   * The callback will be executed once for each handle that is still active.
-   *
-   * @param callback A function to be invoked once for each active handle.
-   */
-  void Walk(function_ref<void(Handle&)> callback);
-
-  /**
-   * Reinitialize any kernel state necessary in the child process after
-   * a fork(2) system call.
-   *
-   * Previously started watchers will continue to be started in the child
-   * process.
-   *
-   * It is necessary to explicitly call this function on every event loop
-   * created in the parent process that you plan to continue to use in the
-   * child, including the default loop (even if you don’t continue to use it
-   * in the parent). This function must be called before calling any API
-   * function using the loop in the child. Failure to do so will result in
-   * undefined behaviour, possibly including duplicate events delivered to
-   * both parent and child or aborting the child process.
-   *
-   * When possible, it is preferred to create a new loop in the child process
-   * instead of reusing a loop created in the parent. New loops created in the
-   * child process after the fork should not use this function.
-   *
-   * Note that this function is not implemented on Windows.
-   * Note also that this function is experimental in `libuv`. It may contain
-   * bugs, and is subject to change or removal. API and ABI stability is not
-   * guaranteed.
-   *
-   * error() will be emitted in case of errors.
-   */
-  void Fork();
-
-  /**
-   * Get the underlying event loop data structure.
-   *
-   * @return The underlying event loop data structure.
-   */
-  uv_loop_t* GetRaw() const noexcept { return m_loop; }
-
-  /**
-   * Gets user-defined data.
-   * @return User-defined data if any, nullptr otherwise.
-   */
-  template <typename T = void>
-  std::shared_ptr<T> GetData() const {
-    return std::static_pointer_cast<T>(m_data);
-  }
-
-  /**
-   * Sets user-defined data.
-   * @param data User-defined arbitrary data.
-   */
-  void SetData(std::shared_ptr<void> data) { m_data = std::move(data); }
-
-  /**
-   * Get the thread id of the loop thread.  If the loop is not currently
-   * running, returns default-constructed thread id.
-   */
-  std::thread::id GetThreadId() const { return m_tid; }
-
-  /**
-   * Error signal
-   */
-  sig::Signal<Error> error;
-
-  /**
-   * Reports error.
-   * @param err Error code
-   */
-  void ReportError(int err) { error(Error(err)); }
-
- private:
-  std::shared_ptr<void> m_data;
-  uv_loop_t* m_loop;
-  uv_loop_t m_loopStruct;
-  std::atomic<std::thread::id> m_tid;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_LOOP_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/NetworkStream.h b/wpiutil/src/main/native/include/wpi/uv/NetworkStream.h
deleted file mode 100644
index faac9fe..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/NetworkStream.h
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_NETWORKSTREAM_H_
-#define WPIUTIL_WPI_UV_NETWORKSTREAM_H_
-
-#include <uv.h>
-
-#include <cstdlib>
-#include <functional>
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Stream.h"
-
-namespace wpi::uv {
-
-class NetworkStream;
-
-/**
- * Connection request.
- */
-class ConnectReq : public RequestImpl<ConnectReq, uv_connect_t> {
- public:
-  ConnectReq();
-
-  NetworkStream& GetStream() const {
-    return *static_cast<NetworkStream*>(GetRaw()->handle->data);
-  }
-
-  /**
-   * Connection completed signal.
-   */
-  sig::Signal<> connected;
-};
-
-/**
- * Network stream handle.
- * This is an abstract type; there are two network stream implementations (Tcp
- * and Pipe).
- */
-class NetworkStream : public Stream {
- public:
-  static constexpr int kDefaultBacklog = 128;
-
-  std::shared_ptr<NetworkStream> shared_from_this() {
-    return std::static_pointer_cast<NetworkStream>(Handle::shared_from_this());
-  }
-
-  std::shared_ptr<const NetworkStream> shared_from_this() const {
-    return std::static_pointer_cast<const NetworkStream>(
-        Handle::shared_from_this());
-  }
-
-  /**
-   * Start listening for incoming connections.  When a new incoming connection
-   * is received the connection signal is generated.
-   * @param backlog the number of connections the kernel might queue, same as
-   *        listen(2).
-   */
-  void Listen(int backlog = kDefaultBacklog);
-
-  /**
-   * Start listening for incoming connections.  This is a convenience wrapper
-   * around `Listen(int)` that also connects a callback to the connection
-   * signal.  When a new incoming connection is received the connection signal
-   * is generated (and the callback is called).
-   * @param callback the callback to call when a connection is received.
-   *        `Accept()` should be called from this callback.
-   * @param backlog the number of connections the kernel might queue, same as
-   *        listen(2).
-   */
-  void Listen(std::function<void()> callback, int backlog = kDefaultBacklog);
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a ListenEvent event to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @return The stream handle for the accepted connection, or nullptr on error.
-   */
-  std::shared_ptr<NetworkStream> Accept() {
-    return DoAccept()->shared_from_this();
-  }
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a connection signal to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @param client Client stream object.
-   * @return False on error.
-   */
-  bool Accept(const std::shared_ptr<NetworkStream>& client) {
-    return Invoke(&uv_accept, GetRawStream(), client->GetRawStream());
-  }
-
-  /**
-   * Signal generated when an incoming connection is received.
-   */
-  sig::Signal<> connection;
-
- protected:
-  explicit NetworkStream(uv_stream_t* uv_stream) : Stream{uv_stream} {}
-
-  virtual NetworkStream* DoAccept() = 0;
-};
-
-template <typename T, typename U>
-class NetworkStreamImpl : public NetworkStream {
- public:
-  std::shared_ptr<T> shared_from_this() {
-    return std::static_pointer_cast<T>(Handle::shared_from_this());
-  }
-
-  std::shared_ptr<const T> shared_from_this() const {
-    return std::static_pointer_cast<const T>(Handle::shared_from_this());
-  }
-
-  /**
-   * Get the underlying handle data structure.
-   *
-   * @return The underlying handle data structure.
-   */
-  U* GetRaw() const noexcept {
-    return reinterpret_cast<U*>(this->GetRawHandle());
-  }
-
- protected:
-  NetworkStreamImpl()
-      : NetworkStream{static_cast<uv_stream_t*>(std::malloc(sizeof(U)))} {}
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_NETWORKSTREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Pipe.h b/wpiutil/src/main/native/include/wpi/uv/Pipe.h
deleted file mode 100644
index e223268..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Pipe.h
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_PIPE_H_
-#define WPIUTIL_WPI_UV_PIPE_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/uv/NetworkStream.h"
-
-namespace wpi::uv {
-
-class Loop;
-class PipeConnectReq;
-
-/**
- * Pipe handle.
- * Pipe handles provide an abstraction over local domain sockets on Unix and
- * named pipes on Windows.
- */
-class Pipe final : public NetworkStreamImpl<Pipe, uv_pipe_t> {
-  struct private_init {};
-
- public:
-  explicit Pipe(const private_init&) {}
-  ~Pipe() noexcept override = default;
-
-  /**
-   * Create a pipe handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param ipc Indicates if this pipe will be used for handle passing between
-   *            processes.
-   */
-  static std::shared_ptr<Pipe> Create(Loop& loop, bool ipc = false);
-
-  /**
-   * Create a pipe handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param ipc Indicates if this pipe will be used for handle passing between
-   *            processes.
-   */
-  static std::shared_ptr<Pipe> Create(const std::shared_ptr<Loop>& loop,
-                                      bool ipc = false) {
-    return Create(*loop, ipc);
-  }
-
-  /**
-   * Reuse this handle.  This closes the handle, and after the close completes,
-   * reinitializes it (identically to Create) and calls the provided callback.
-   * Unlike Close(), it does NOT emit the closed signal, however, IsClosing()
-   * will return true until the callback is called.  This does nothing if
-   * IsClosing() is true (e.g. if Close() was called).
-   *
-   * @param ipc IPC
-   * @param callback Callback
-   */
-  void Reuse(std::function<void()> callback, bool ipc = false);
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a ListenEvent event to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @return The stream handle for the accepted connection, or nullptr on error.
-   */
-  std::shared_ptr<Pipe> Accept();
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a connection signal to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @param client Client stream object.
-   * @return False on error.
-   */
-  bool Accept(const std::shared_ptr<Pipe>& client) {
-    return NetworkStream::Accept(client);
-  }
-
-  /**
-   * Open an existing file descriptor or HANDLE as a pipe.
-   *
-   * @note The passed file descriptor or HANDLE is not checked for its type, but
-   * it's required that it represents a valid pipe.
-   *
-   * @param file A valid file handle (either a file descriptor or a HANDLE).
-   */
-  void Open(uv_file file) { Invoke(&uv_pipe_open, GetRaw(), file); }
-
-  /**
-   * Bind the pipe to a file path (Unix) or a name (Windows).
-   *
-   * @note Paths on Unix get truncated to `sizeof(sockaddr_un.sun_path)` bytes,
-   * typically between 92 and 108 bytes.
-   *
-   * @param name File path (Unix) or name (Windows).
-   */
-  void Bind(std::string_view name);
-
-  /**
-   * Connect to the Unix domain socket or the named pipe.
-   *
-   * @note Paths on Unix get truncated to `sizeof(sockaddr_un.sun_path)` bytes,
-   * typically between 92 and 108 bytes.
-   *
-   * HandleConnected() is called on the request when the connection has been
-   * established.
-   * HandleError() is called on the request in case of errors during the
-   * connection.
-   *
-   * @param name File path (Unix) or name (Windows).
-   * @param req connection request
-   */
-  void Connect(std::string_view name,
-               const std::shared_ptr<PipeConnectReq>& req);
-
-  /**
-   * Connect to the Unix domain socket or the named pipe.
-   *
-   * @note Paths on Unix get truncated to `sizeof(sockaddr_un.sun_path)` bytes,
-   * typically between 92 and 108 bytes.
-   *
-   * The callback is called when the connection has been established.  Errors
-   * are reported to the stream error handler.
-   *
-   * @param name File path (Unix) or name (Windows).
-   * @param callback Callback function to call when connection established
-   */
-  void Connect(std::string_view name, std::function<void()> callback);
-
-  /**
-   * Get the name of the Unix domain socket or the named pipe.
-   * @return The name (will be empty if an error occurred).
-   */
-  std::string GetSock();
-
-  /**
-   * Get the name of the Unix domain socket or the named pipe to which the
-   * handle is connected.
-   * @return The name (will be empty if an error occurred).
-   */
-  std::string GetPeer();
-
-  /**
-   * Set the number of pending pipe instance handles when the pipe server is
-   * waiting for connections.
-   * @note This setting applies to Windows only.
-   * @param count Number of pending handles.
-   */
-  void SetPendingInstances(int count) {
-    uv_pipe_pending_instances(GetRaw(), count);
-  }
-
-  /**
-   * Alters pipe permissions, allowing it to be accessed from processes run
-   * by different users.  Makes the pipe writable or readable by all users.
-   * Mode can be UV_WRITABLE, UV_READABLE, or both.  This function is blocking.
-   * @param flags chmod flags
-   */
-  void Chmod(int flags) { Invoke(&uv_pipe_chmod, GetRaw(), flags); }
-
- private:
-  Pipe* DoAccept() override;
-
-  struct ReuseData {
-    std::function<void()> callback;
-    bool ipc;
-  };
-  std::unique_ptr<ReuseData> m_reuseData;
-};
-
-/**
- * Pipe connection request.
- */
-class PipeConnectReq : public ConnectReq {
- public:
-  Pipe& GetStream() const {
-    return *static_cast<Pipe*>(&ConnectReq::GetStream());
-  }
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_PIPE_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Poll.h b/wpiutil/src/main/native/include/wpi/uv/Poll.h
deleted file mode 100644
index 6e1e26d..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Poll.h
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_POLL_H_
-#define WPIUTIL_WPI_UV_POLL_H_
-
-#include <uv.h>
-
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Poll handle.
- */
-class Poll final : public HandleImpl<Poll, uv_poll_t> {
-  struct private_init {};
-
- public:
-  explicit Poll(const private_init&) {}
-  ~Poll() noexcept override = default;
-
-  /**
-   * Create a poll handle using a file descriptor.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param fd File descriptor.
-   */
-  static std::shared_ptr<Poll> Create(Loop& loop, int fd);
-
-  /**
-   * Create a poll handle using a file descriptor.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param fd File descriptor.
-   */
-  static std::shared_ptr<Poll> Create(const std::shared_ptr<Loop>& loop,
-                                      int fd) {
-    return Create(*loop, fd);
-  }
-
-  /**
-   * Create a poll handle using a socket descriptor.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param sock Socket descriptor.
-   */
-  static std::shared_ptr<Poll> CreateSocket(Loop& loop, uv_os_sock_t sock);
-
-  /**
-   * Create a poll handle using a socket descriptor.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param sock Socket descriptor.
-   */
-  static std::shared_ptr<Poll> CreateSocket(const std::shared_ptr<Loop>& loop,
-                                            uv_os_sock_t sock) {
-    return CreateSocket(*loop, sock);
-  }
-
-  /**
-   * Reuse this handle.  This closes the handle, and after the close completes,
-   * reinitializes it (identically to Create) and calls the provided callback.
-   * Unlike Close(), it does NOT emit the closed signal, however, IsClosing()
-   * will return true until the callback is called.  This does nothing if
-   * IsClosing() is true (e.g. if Close() was called).
-   *
-   * @param fd File descriptor
-   * @param callback Callback
-   */
-  void Reuse(int fd, std::function<void()> callback);
-
-  /**
-   * Reuse this handle.  This closes the handle, and after the close completes,
-   * reinitializes it (identically to CreateSocket) and calls the provided
-   * callback.  Unlike Close(), it does NOT emit the closed signal, however,
-   * IsClosing() will return true until the callback is called.  This does
-   * nothing if IsClosing() is true (e.g. if Close() was called).
-   *
-   * @param sock Socket descriptor.
-   * @param callback Callback
-   */
-  void ReuseSocket(uv_os_sock_t sock, std::function<void()> callback);
-
-  /**
-   * Start polling the file descriptor.
-   *
-   * @param events Bitmask of events (UV_READABLE, UV_WRITEABLE, UV_PRIORITIZED,
-   *               and UV_DISCONNECT).
-   */
-  void Start(int events);
-
-  /**
-   * Stop polling the file descriptor.
-   */
-  void Stop() { Invoke(&uv_poll_stop, GetRaw()); }
-
-  /**
-   * Signal generated when a poll event occurs.
-   */
-  sig::Signal<int> pollEvent;
-
- private:
-  struct ReuseData {
-    std::function<void()> callback;
-    bool isSocket;
-    int fd;
-    uv_os_sock_t sock;
-  };
-  std::unique_ptr<ReuseData> m_reuseData;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_POLL_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Prepare.h b/wpiutil/src/main/native/include/wpi/uv/Prepare.h
deleted file mode 100644
index 88ae2d9..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Prepare.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_PREPARE_H_
-#define WPIUTIL_WPI_UV_PREPARE_H_
-
-#include <uv.h>
-
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Prepare handle.
- * Prepare handles will generate a signal once per loop iteration, right
- * before polling for I/O.
- */
-class Prepare final : public HandleImpl<Prepare, uv_prepare_t> {
-  struct private_init {};
-
- public:
-  explicit Prepare(const private_init&) {}
-  ~Prepare() noexcept override = default;
-
-  /**
-   * Create a prepare handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Prepare> Create(Loop& loop);
-
-  /**
-   * Create a prepare handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Prepare> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Start the handle.
-   */
-  void Start();
-
-  /**
-   * Stop the handle.  The signal will no longer be generated.
-   */
-  void Stop() { Invoke(&uv_prepare_stop, GetRaw()); }
-
-  /**
-   * Signal generated once per loop iteration prior to polling for I/O.
-   */
-  sig::Signal<> prepare;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_PREPARE_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Process.h b/wpiutil/src/main/native/include/wpi/uv/Process.h
deleted file mode 100644
index fc2315e..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Process.h
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_PROCESS_H_
-#define WPIUTIL_WPI_UV_PROCESS_H_
-
-#include <uv.h>
-
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <string_view>
-
-#include "wpi/Signal.h"
-#include "wpi/SmallVector.h"
-#include "wpi/span.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-class Pipe;
-
-/**
- * Process handle.
- * Process handles will spawn a new process and allow the user to control it
- * and establish communication channels with it using streams.
- */
-class Process final : public HandleImpl<Process, uv_process_t> {
-  struct private_init {};
-
- public:
-  explicit Process(const private_init&) {}
-  ~Process() noexcept override = default;
-
-  /**
-   * Structure for Spawn() option temporaries.  This is a reference type, so if
-   * this value is stored outside of a temporary, be careful about overwriting
-   * what it points to.
-   */
-  struct Option {
-    enum Type {
-      kNone,
-      kArg,
-      kEnv,
-      kCwd,
-      kUid,
-      kGid,
-      kSetFlags,
-      kClearFlags,
-      kStdioIgnore,
-      kStdioInheritFd,
-      kStdioInheritPipe,
-      kStdioCreatePipe
-    };
-
-    Option() : m_type(kNone) {}
-
-    /*implicit*/ Option(const char* arg) {  // NOLINT
-      m_data.str = arg;
-    }
-
-    /*implicit*/ Option(const std::string& arg) {  // NOLINT
-      m_data.str = arg.data();
-    }
-
-    /*implicit*/ Option(std::string_view arg)  // NOLINT
-        : m_strData(arg) {
-      m_data.str = m_strData.c_str();
-    }
-
-    /*implicit*/ Option(const SmallVectorImpl<char>& arg)  // NOLINT
-        : m_strData(arg.data(), arg.size()) {
-      m_data.str = m_strData.c_str();
-    }
-
-    explicit Option(Type type) : m_type(type) {}
-
-    Type m_type = kArg;
-    std::string m_strData;
-    union {
-      const char* str;
-      uv_uid_t uid;
-      uv_gid_t gid;
-      unsigned int flags;
-      struct {
-        size_t index;
-        union {
-          int fd;
-          Pipe* pipe;
-        };
-        unsigned int flags;
-      } stdio;
-    } m_data;
-  };
-
-  /**
-   * Set environment variable for the subprocess.  If not set, the parent's
-   * environment is used.
-   * @param env environment variable
-   */
-  static Option Env(std::string_view env) {
-    Option o(Option::kEnv);
-    o.m_strData = env;
-    o.m_data.str = o.m_strData.c_str();
-    return o;
-  }
-
-  /**
-   * Set the current working directory for the subprocess.
-   * @param cwd current working directory
-   */
-  static Option Cwd(std::string_view cwd) {
-    Option o(Option::kCwd);
-    o.m_strData = cwd;
-    o.m_data.str = o.m_strData.c_str();
-    return o;
-  }
-
-  /**
-   * Set the child process' user id.
-   * @param uid user id
-   */
-  static Option Uid(uv_uid_t uid) {
-    Option o(Option::kUid);
-    o.m_data.uid = uid;
-    return o;
-  }
-
-  /**
-   * Set the child process' group id.
-   * @param gid group id
-   */
-  static Option Gid(uv_gid_t gid) {
-    Option o(Option::kGid);
-    o.m_data.gid = gid;
-    return o;
-  }
-
-  /**
-   * Set spawn flags.
-   * @param flags Bitmask values from uv_process_flags.
-   */
-  static Option SetFlags(unsigned int flags) {
-    Option o(Option::kSetFlags);
-    o.m_data.flags = flags;
-    return o;
-  }
-
-  /**
-   * Clear spawn flags.
-   * @param flags Bitmask values from uv_process_flags.
-   */
-  static Option ClearFlags(unsigned int flags) {
-    Option o(Option::kClearFlags);
-    o.m_data.flags = flags;
-    return o;
-  }
-
-  /**
-   * Explicitly ignore a stdio.
-   * @param index stdio index
-   */
-  static Option StdioIgnore(size_t index) {
-    Option o(Option::kStdioIgnore);
-    o.m_data.stdio.index = index;
-    return o;
-  }
-
-  /**
-   * Inherit a file descriptor from the parent process.
-   * @param index stdio index
-   * @param fd parent file descriptor
-   */
-  static Option StdioInherit(size_t index, int fd) {
-    Option o(Option::kStdioInheritFd);
-    o.m_data.stdio.index = index;
-    o.m_data.stdio.fd = fd;
-    return o;
-  }
-
-  /**
-   * Inherit a pipe from the parent process.
-   * @param index stdio index
-   * @param pipe pipe
-   */
-  static Option StdioInherit(size_t index, Pipe& pipe) {
-    Option o(Option::kStdioInheritPipe);
-    o.m_data.stdio.index = index;
-    o.m_data.stdio.pipe = &pipe;
-    return o;
-  }
-
-  /**
-   * Create a pipe between the child and the parent.
-   * @param index stdio index
-   * @param pipe pipe
-   * @param flags Some combination of UV_READABLE_PIPE, UV_WRITABLE_PIPE, and
-   *              UV_OVERLAPPED_PIPE (Windows only, ignored on Unix).
-   */
-  static Option StdioCreatePipe(size_t index, Pipe& pipe, unsigned int flags) {
-    Option o(Option::kStdioCreatePipe);
-    o.m_data.stdio.index = index;
-    o.m_data.stdio.pipe = &pipe;
-    o.m_data.stdio.flags = flags;
-    return o;
-  }
-
-  /**
-   * Disables inheritance for file descriptors / handles that this process
-   * inherited from its parent.  The effect is that child processes spawned
-   * by this process don't accidentally inherit these handles.
-   *
-   * It is recommended to call this function as early in your program as
-   * possible, before the inherited file descriptors can be closed or
-   * duplicated.
-   */
-  static void DisableStdioInheritance() { uv_disable_stdio_inheritance(); }
-
-  /**
-   * Starts a process.  If the process is not successfully spawned, an error
-   * is generated on the loop and this function returns nullptr.
-   *
-   * Possible reasons for failing to spawn would include (but not be limited to)
-   * the file to execute not existing, not having permissions to use the setuid
-   * or setgid specified, or not having enough memory to allocate for the new
-   * process.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param file Path pointing to the program to be executed
-   * @param options Process options
-   */
-  static std::shared_ptr<Process> SpawnArray(Loop& loop, std::string_view file,
-                                             span<const Option> options);
-
-  static std::shared_ptr<Process> SpawnArray(
-      Loop& loop, std::string_view file,
-      std::initializer_list<Option> options) {
-    return SpawnArray(loop, file, {options.begin(), options.end()});
-  }
-
-  template <typename... Args>
-  static std::shared_ptr<Process> Spawn(Loop& loop, std::string_view file,
-                                        const Args&... options) {
-    return SpawnArray(loop, file, {options...});
-  }
-
-  /**
-   * Starts a process.  If the process is not successfully spawned, an error
-   * is generated on the loop and this function returns nullptr.
-   *
-   * Possible reasons for failing to spawn would include (but not be limited to)
-   * the file to execute not existing, not having permissions to use the setuid
-   * or setgid specified, or not having enough memory to allocate for the new
-   * process.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param file Path pointing to the program to be executed
-   * @param options Process options
-   */
-  static std::shared_ptr<Process> SpawnArray(const std::shared_ptr<Loop>& loop,
-                                             std::string_view file,
-                                             span<const Option> options) {
-    return SpawnArray(*loop, file, options);
-  }
-
-  static std::shared_ptr<Process> SpawnArray(
-      const std::shared_ptr<Loop>& loop, std::string_view file,
-      std::initializer_list<Option> options) {
-    return SpawnArray(*loop, file, options);
-  }
-
-  template <typename... Args>
-  static std::shared_ptr<Process> Spawn(const std::shared_ptr<Loop>& loop,
-                                        std::string_view file,
-                                        const Args&... options) {
-    return SpawnArray(*loop, file, {options...});
-  }
-
-  /**
-   * Sends the specified signal to the process.
-   * @param signum signal number
-   */
-  void Kill(int signum) { Invoke(&uv_process_kill, GetRaw(), signum); }
-
-  /**
-   * Sends the specified signal to the given PID.
-   * @param pid process ID
-   * @param signum signal number
-   * @return 0 on success, otherwise error code.
-   */
-  static int Kill(int pid, int signum) noexcept { return uv_kill(pid, signum); }
-
-  /**
-   * Get the process ID.
-   * @return Process ID.
-   */
-  uv_pid_t GetPid() const noexcept { return GetRaw()->pid; }
-
-  /**
-   * Signal generated when the process exits.  The parameters are the exit
-   * status and the signal that caused the process to terminate, if any.
-   */
-  sig::Signal<int64_t, int> exited;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_PROCESS_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Request.h b/wpiutil/src/main/native/include/wpi/uv/Request.h
deleted file mode 100644
index 3f6a19d..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Request.h
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_REQUEST_H_
-#define WPIUTIL_WPI_UV_REQUEST_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-
-#include "wpi/uv/Error.h"
-
-namespace wpi::uv {
-
-/**
- * Request.  Requests are not moveable or copyable.
- * This class provides shared_ptr ownership and shared_from_this.
- */
-class Request : public std::enable_shared_from_this<Request> {
- public:
-  using Type = uv_req_type;
-
-  Request(const Request&) = delete;
-  Request(Request&&) = delete;
-  Request& operator=(const Request&) = delete;
-  Request& operator=(Request&&) = delete;
-  virtual ~Request() noexcept = default;
-
-  /**
-   * Get the type of the request.
-   *
-   * A base request offers no functionality to promote it to the actual request
-   * type. By means of this function, the type of the underlying request as
-   * specified by Type is made available.
-   *
-   * @return The actual type of the request.
-   */
-  Type GetType() const noexcept { return m_uv_req->type; }
-
-  /**
-   * Get the name of the type of the request.  E.g. "connect" for connect.
-   */
-  const char* GetTypeName() const noexcept {
-    return uv_req_type_name(m_uv_req->type);
-  }
-
-  /**
-   * Cancel a pending request.
-   *
-   * This method fails if the request is executing or has finished
-   * executing.
-   * It can emit an error signal in case of errors.
-   *
-   * @return True in case of success, false otherwise.
-   */
-  bool Cancel() { return uv_cancel(m_uv_req) == 0; }
-
-  /**
-   * Return the size of the underlying request type.
-   * @return The size of the underlying request type.
-   */
-  size_t RawSize() const noexcept { return uv_req_size(m_uv_req->type); }
-
-  /**
-   * Get the underlying request data structure.
-   *
-   * @return The underlying request data structure.
-   */
-  uv_req_t* GetRawReq() noexcept { return m_uv_req; }
-
-  /**
-   * Get the underlying request data structure.
-   *
-   * @return The underlying request data structure.
-   */
-  const uv_req_t* GetRawReq() const noexcept { return m_uv_req; }
-
-  /**
-   * Keep this request in memory even if no outside shared_ptr references
-   * remain.  To release call Release().
-   *
-   * Derived classes can override this method for different memory management
-   * approaches (e.g. pooled storage of requests).
-   */
-  virtual void Keep() noexcept { m_self = shared_from_this(); }
-
-  /**
-   * No longer force holding this request in memory.  Does not immediately
-   * destroy the object unless no outside shared_ptr references remain.
-   *
-   * Derived classes can override this method for different memory management
-   * approaches (e.g. pooled storage of requests).
-   */
-  virtual void Release() noexcept { m_self.reset(); }
-
-  /**
-   * Error callback.  By default, this is set up to report errors to the handle
-   * that created this request.
-   * @param err error code
-   */
-  std::function<void(Error)> error;
-
-  /**
-   * Report an error.
-   * @param err Error code
-   */
-  void ReportError(int err) { error(Error(err)); }
-
- protected:
-  /**
-   * Constructor.
-   */
-  explicit Request(uv_req_t* uv_req) : m_uv_req{uv_req} {
-    m_uv_req->data = this;
-  }
-
- private:
-  std::shared_ptr<Request> m_self;
-  uv_req_t* m_uv_req;
-};
-
-/**
- * Request.  Requests are not moveable or copyable.
- * @tparam T CRTP derived class
- * @tparam U underlying libuv request type
- */
-template <typename T, typename U>
-class RequestImpl : public Request {
- public:
-  std::shared_ptr<T> shared_from_this() {
-    return std::static_pointer_cast<T>(this->shared_from_this());
-  }
-
-  std::shared_ptr<const T> shared_from_this() const {
-    return std::static_pointer_cast<const T>(this->shared_from_this());
-  }
-
-  /**
-   * Get the underlying request data structure.
-   *
-   * @return The underlying request data structure.
-   */
-  U* GetRaw() noexcept { return &m_uv_req; }
-
-  /**
-   * Get the underlying request data structure.
-   *
-   * @return The underlying request data structure.
-   */
-  const U* GetRaw() const noexcept { return &m_uv_req; }
-
- protected:
-  /**
-   * Constructor.
-   */
-  RequestImpl() : Request{reinterpret_cast<uv_req_t*>(&m_uv_req)} {}
-
- private:
-  U m_uv_req;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_REQUEST_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Signal.h b/wpiutil/src/main/native/include/wpi/uv/Signal.h
deleted file mode 100644
index 9abcad3..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Signal.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_SIGNAL_H_
-#define WPIUTIL_WPI_UV_SIGNAL_H_
-
-#include <uv.h>
-
-#include <memory>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Signal handle.
- */
-class Signal final : public HandleImpl<Signal, uv_signal_t> {
-  struct private_init {};
-
- public:
-  explicit Signal(const private_init&) {}
-  ~Signal() noexcept override = default;
-
-  /**
-   * Create a signal handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Signal> Create(Loop& loop);
-
-  /**
-   * Create a signal handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Signal> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Start watching for the given signal.
-   *
-   * @param signum Signal to watch for.
-   */
-  void Start(int signum);
-
-  /**
-   * Start watching for the given signal.  Same as Start() but the signal
-   * handler is reset the moment the signal is received.
-   *
-   * @param signum Signal to watch for.
-   */
-  void StartOneshot(int signum);
-
-  /**
-   * Stop watching for the signal.
-   */
-  void Stop() { Invoke(&uv_signal_stop, GetRaw()); }
-
-  /**
-   * Get the signal being monitored.
-   * @return Signal number.
-   */
-  int GetSignal() const { return GetRaw()->signum; }
-
-  /**
-   * Signal generated when a signal occurs.
-   */
-  sig::Signal<int> signal;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_SIGNAL_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Stream.h b/wpiutil/src/main/native/include/wpi/uv/Stream.h
deleted file mode 100644
index 0ade972..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Stream.h
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_STREAM_H_
-#define WPIUTIL_WPI_UV_STREAM_H_
-
-#include <uv.h>
-
-#include <cstdlib>
-#include <functional>
-#include <initializer_list>
-#include <memory>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/span.h"
-#include "wpi/uv/Buffer.h"
-#include "wpi/uv/Handle.h"
-#include "wpi/uv/Request.h"
-
-namespace wpi::uv {
-
-class Stream;
-
-/**
- * Shutdown request.
- */
-class ShutdownReq : public RequestImpl<ShutdownReq, uv_shutdown_t> {
- public:
-  ShutdownReq();
-
-  Stream& GetStream() const {
-    return *static_cast<Stream*>(GetRaw()->handle->data);
-  }
-
-  /**
-   * Shutdown completed signal.
-   */
-  sig::Signal<> complete;
-};
-
-/**
- * Write request.
- */
-class WriteReq : public RequestImpl<WriteReq, uv_write_t> {
- public:
-  WriteReq();
-
-  Stream& GetStream() const {
-    return *static_cast<Stream*>(GetRaw()->handle->data);
-  }
-
-  /**
-   * Write completed signal.  This is called even if an error occurred.
-   * @param err error value
-   */
-  sig::Signal<Error> finish;
-};
-
-/**
- * Stream handle.
- * Stream handles provide an abstraction of a duplex communication channel.
- * This is an abstract type; there are three stream implementations (Tcp,
- * Pipe, and Tty).
- */
-class Stream : public Handle {
- public:
-  std::shared_ptr<Stream> shared_from_this() {
-    return std::static_pointer_cast<Stream>(Handle::shared_from_this());
-  }
-
-  std::shared_ptr<const Stream> shared_from_this() const {
-    return std::static_pointer_cast<const Stream>(Handle::shared_from_this());
-  }
-
-  /**
-   * Shutdown the outgoing (write) side of a duplex stream. It waits for pending
-   * write requests to complete.  HandleShutdownComplete() is called on the
-   * request after shutdown is complete.
-   *
-   * @param req shutdown request
-   */
-  void Shutdown(const std::shared_ptr<ShutdownReq>& req);
-
-  /**
-   * Shutdown the outgoing (write) side of a duplex stream. It waits for pending
-   * write requests to complete.  The callback is called after shutdown is
-   * complete.  Errors will be reported to the stream error handler.
-   *
-   * @param callback Callback function to call when shutdown completes
-   * @return Connection object for the callback
-   */
-  void Shutdown(std::function<void()> callback = nullptr);
-
-  /**
-   * Start reading data from an incoming stream.
-   *
-   * This will only succeed after a connection has been established.
-   *
-   * A data signal will be emitted several times until there is no more
-   * data to read or `StopRead()` is called.
-   * An end signal will be emitted when there is no more data to read.
-   */
-  void StartRead();
-
-  /**
-   * Stop reading data from the stream.
-   *
-   * This function is idempotent and may be safely called on a stopped stream.
-   */
-  void StopRead() { Invoke(&uv_read_stop, GetRawStream()); }
-
-  /**
-   * Write data to the stream.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the write request.
-   * An easy way to ensure this is to have the write request keep track of
-   * the data and use either its Complete() function or destructor to free the
-   * data.
-   *
-   * The finish signal will be emitted on the request object when the data
-   * has been written (or if an error occurs).
-   * The error signal will be emitted on the request object in case of errors.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param req write request
-   */
-  void Write(span<const Buffer> bufs, const std::shared_ptr<WriteReq>& req);
-
-  /**
-   * Write data to the stream.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the write request.
-   * An easy way to ensure this is to have the write request keep track of
-   * the data and use either its Complete() function or destructor to free the
-   * data.
-   *
-   * The finish signal will be emitted on the request object when the data
-   * has been written (or if an error occurs).
-   * The error signal will be emitted on the request object in case of errors.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param req write request
-   */
-  void Write(std::initializer_list<Buffer> bufs,
-             const std::shared_ptr<WriteReq>& req) {
-    Write({bufs.begin(), bufs.end()}, req);
-  }
-
-  /**
-   * Write data to the stream.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the write request.
-   * The callback can be used to free data after the request completes.
-   *
-   * The callback will be called when the data has been written (even if an
-   * error occurred).  Errors will be reported to the stream error handler.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param callback Callback function to call when the write completes
-   */
-  void Write(span<const Buffer> bufs,
-             std::function<void(span<Buffer>, Error)> callback);
-
-  /**
-   * Write data to the stream.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the write request.
-   * The callback can be used to free data after the request completes.
-   *
-   * The callback will be called when the data has been written (even if an
-   * error occurred).  Errors will be reported to the stream error handler.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param callback Callback function to call when the write completes
-   */
-  void Write(std::initializer_list<Buffer> bufs,
-             std::function<void(span<Buffer>, Error)> callback) {
-    Write({bufs.begin(), bufs.end()}, std::move(callback));
-  }
-
-  /**
-   * Queue a write request if it can be completed immediately.
-   *
-   * Same as `Write()`, but won’t queue a write request if it can’t be
-   * completed immediately.
-   * An error signal will be emitted in case of errors.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @return Number of bytes written.
-   */
-  int TryWrite(span<const Buffer> bufs);
-
-  /**
-   * Queue a write request if it can be completed immediately.
-   *
-   * Same as `Write()`, but won’t queue a write request if it can’t be
-   * completed immediately.
-   * An error signal will be emitted in case of errors.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @return Number of bytes written.
-   */
-  int TryWrite(std::initializer_list<Buffer> bufs) {
-    return TryWrite({bufs.begin(), bufs.end()});
-  }
-
-  /**
-   * Check if the stream is readable.
-   * @return True if the stream is readable, false otherwise.
-   */
-  bool IsReadable() const noexcept {
-    return uv_is_readable(GetRawStream()) == 1;
-  }
-
-  /**
-   * @brief Checks if the stream is writable.
-   * @return True if the stream is writable, false otherwise.
-   */
-  bool IsWritable() const noexcept {
-    return uv_is_writable(GetRawStream()) == 1;
-  }
-
-  /**
-   * Enable or disable blocking mode for a stream.
-   *
-   * When blocking mode is enabled all writes complete synchronously. The
-   * interface remains unchanged otherwise, e.g. completion or failure of the
-   * operation will still be reported through events which are emitted
-   * asynchronously.
-   *
-   * @param enable True to enable blocking mode, false otherwise.
-   * @return True in case of success, false otherwise.
-   */
-  bool SetBlocking(bool enable) noexcept {
-    return uv_stream_set_blocking(GetRawStream(), enable) == 0;
-  }
-
-  /**
-   * Gets the amount of queued bytes waiting to be sent.
-   * @return Amount of queued bytes waiting to be sent.
-   */
-  size_t GetWriteQueueSize() const noexcept {
-    return GetRawStream()->write_queue_size;
-  }
-
-  /**
-   * Get the underlying stream data structure.
-   *
-   * @return The underlying stream data structure.
-   */
-  uv_stream_t* GetRawStream() const noexcept {
-    return reinterpret_cast<uv_stream_t*>(GetRawHandle());
-  }
-
-  /**
-   * Signal generated when data was read on a stream.
-   */
-  sig::Signal<Buffer&, size_t> data;
-
-  /**
-   * Signal generated when no more read data is available.
-   */
-  sig::Signal<> end;
-
- protected:
-  explicit Stream(uv_stream_t* uv_stream)
-      : Handle{reinterpret_cast<uv_handle_t*>(uv_stream)} {}
-};
-
-template <typename T, typename U>
-class StreamImpl : public Stream {
- public:
-  std::shared_ptr<T> shared_from_this() {
-    return std::static_pointer_cast<T>(Handle::shared_from_this());
-  }
-
-  std::shared_ptr<const T> shared_from_this() const {
-    return std::static_pointer_cast<const T>(Handle::shared_from_this());
-  }
-
-  /**
-   * Get the underlying handle data structure.
-   *
-   * @return The underlying handle data structure.
-   */
-  U* GetRaw() const noexcept {
-    return reinterpret_cast<U*>(this->GetRawHandle());
-  }
-
- protected:
-  StreamImpl() : Stream{static_cast<uv_stream_t*>(std::malloc(sizeof(U)))} {}
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_STREAM_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Tcp.h b/wpiutil/src/main/native/include/wpi/uv/Tcp.h
deleted file mode 100644
index c712f0b..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Tcp.h
+++ /dev/null
@@ -1,363 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_TCP_H_
-#define WPIUTIL_WPI_UV_TCP_H_
-
-#include <uv.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-#include "wpi/uv/NetworkStream.h"
-
-namespace wpi::uv {
-
-class Loop;
-class TcpConnectReq;
-
-/**
- * TCP handle.
- * TCP handles are used to represent both TCP streams and servers.
- */
-class Tcp final : public NetworkStreamImpl<Tcp, uv_tcp_t> {
-  struct private_init {};
-
- public:
-  using Time = std::chrono::duration<uint64_t, std::milli>;
-
-  explicit Tcp(const private_init&) {}
-  ~Tcp() noexcept override = default;
-
-  /**
-   * Create a TCP handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param flags Flags
-   */
-  static std::shared_ptr<Tcp> Create(Loop& loop,
-                                     unsigned int flags = AF_UNSPEC);
-
-  /**
-   * Create a TCP handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param flags Flags
-   */
-  static std::shared_ptr<Tcp> Create(const std::shared_ptr<Loop>& loop,
-                                     unsigned int flags = AF_UNSPEC) {
-    return Create(*loop, flags);
-  }
-
-  /**
-   * Reuse this handle.  This closes the handle, and after the close completes,
-   * reinitializes it (identically to Create) and calls the provided callback.
-   * Unlike Close(), it does NOT emit the closed signal, however, IsClosing()
-   * will return true until the callback is called.  This does nothing if
-   * IsClosing() is true (e.g. if Close() was called).
-   *
-   * @param flags Flags
-   * @param callback Callback
-   */
-  void Reuse(std::function<void()> callback, unsigned int flags = AF_UNSPEC);
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a ListenEvent event to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @return The stream handle for the accepted connection, or nullptr on error.
-   */
-  std::shared_ptr<Tcp> Accept();
-
-  /**
-   * Accept incoming connection.
-   *
-   * This call is used in conjunction with `Listen()` to accept incoming
-   * connections. Call this function after receiving a connection signal to
-   * accept the connection.
-   * An error signal will be emitted in case of errors.
-   *
-   * When the connection signal is emitted it is guaranteed that this
-   * function will complete successfully the first time. If you attempt to use
-   * it more than once, it may fail.
-   * It is suggested to only call this function once per connection signal.
-   *
-   * @param client Client stream object.
-   * @return False on error.
-   */
-  bool Accept(const std::shared_ptr<Tcp>& client) {
-    return NetworkStream::Accept(client);
-  }
-
-  /**
-   * Open an existing file descriptor or SOCKET as a TCP handle.
-   *
-   * @note The passed file descriptor or SOCKET is not checked for its type, but
-   * it's required that it represents a valid stream socket.
-   *
-   * @param sock A valid socket handle (either a file descriptor or a SOCKET).
-   */
-  void Open(uv_os_sock_t sock) { Invoke(&uv_tcp_open, GetRaw(), sock); }
-
-  /**
-   * Enable no delay operation (turns off Nagle's algorithm).
-   * @param enable True to enable it, false otherwise.
-   * @return True in case of success, false otherwise.
-   */
-  bool SetNoDelay(bool enable) { return uv_tcp_nodelay(GetRaw(), enable) == 0; }
-
-  /**
-   * Enable/Disable TCP keep-alive.
-   * @param enable True to enable it, false otherwise.
-   * @param time Initial delay in seconds (use
-   * `std::chrono::duration<unsigned int>`).
-   * @return True in case of success, false otherwise.
-   */
-  bool SetKeepAlive(bool enable, Time time = Time{0}) {
-    return uv_tcp_keepalive(GetRaw(), enable,
-                            static_cast<unsigned>(time.count())) == 0;
-  }
-
-  /**
-   * Enable/Disable simultaneous asynchronous accept requests.
-   *
-   * Enable/Disable simultaneous asynchronous accept requests that are
-   * queued by the operating system when listening for new TCP
-   * connections.
-   * This setting is used to tune a TCP server for the desired performance.
-   * Having simultaneous accepts can significantly improve the rate of
-   * accepting connections (which is why it is enabled by default) but may
-   * lead to uneven load distribution in multi-process setups.
-   *
-   * @param enable True to enable it, false otherwise.
-   * @return True in case of success, false otherwise.
-   */
-  bool SetSimultaneousAccepts(bool enable) {
-    return uv_tcp_simultaneous_accepts(GetRaw(), enable) == 0;
-  }
-
-  /**
-   * Bind the handle to an IPv4 or IPv6 address and port.
-   *
-   * A successful call to this function does not guarantee that the call to
-   * `Listen()` or `Connect()` will work properly.
-   * An error signal can be emitted because of either this function or the
-   * ones mentioned above.
-   *
-   * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
-   * @param flags Optional additional flags.
-   */
-  void Bind(const sockaddr& addr, unsigned int flags = 0) {
-    Invoke(&uv_tcp_bind, GetRaw(), &addr, flags);
-  }
-
-  void Bind(const sockaddr_in& addr, unsigned int flags = 0) {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-
-  void Bind(const sockaddr_in6& addr, unsigned int flags = 0) {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-
-  /**
-   * Bind the handle to an IPv4 address and port.
-   *
-   * A successful call to this function does not guarantee that the call to
-   * `Listen()` or `Connect()` will work properly.
-   * An error signal can be emitted because of either this function or the
-   * ones mentioned above.
-   *
-   * Available flags are:
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   * @param flags Optional additional flags.
-   */
-  void Bind(std::string_view ip, unsigned int port, unsigned int flags = 0);
-
-  /**
-   * Bind the handle to an IPv6 address and port.
-   *
-   * A successful call to this function does not guarantee that the call to
-   * `Listen()` or `Connect()` will work properly.
-   * An error signal can be emitted because of either this function or the
-   * ones mentioned above.
-   *
-   * Available flags are:
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   * @param flags Optional additional flags.
-   */
-  void Bind6(std::string_view ip, unsigned int port, unsigned int flags = 0);
-
-  /**
-   * Get the current address to which the handle is bound.
-   * @return The address (will be zeroed if an error occurred).
-   */
-  sockaddr_storage GetSock();
-
-  /**
-   * Get the address of the peer connected to the handle.
-   * @return The address (will be zeroed if an error occurred).
-   */
-  sockaddr_storage GetPeer();
-
-  /**
-   * Establish an IPv4 or IPv6 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The connected signal is emitted on the request when the connection has been
-   * established.
-   * The error signal is emitted on the request in case of errors during the
-   * connection.
-   *
-   * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
-   * @param req connection request
-   */
-  void Connect(const sockaddr& addr, const std::shared_ptr<TcpConnectReq>& req);
-
-  void Connect(const sockaddr_in& addr,
-               const std::shared_ptr<TcpConnectReq>& req) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), req);
-  }
-
-  void Connect(const sockaddr_in6& addr,
-               const std::shared_ptr<TcpConnectReq>& req) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), req);
-  }
-
-  /**
-   * Establish an IPv4 or IPv6 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The callback is called when the connection has been established.  Errors
-   * are reported to the stream error handler.
-   *
-   * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
-   * @param callback Callback function to call when connection established
-   */
-  void Connect(const sockaddr& addr, std::function<void()> callback);
-
-  void Connect(const sockaddr_in& addr, std::function<void()> callback) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
-  }
-
-  void Connect(const sockaddr_in6& addr, std::function<void()> callback) {
-    Connect(reinterpret_cast<const sockaddr&>(addr), std::move(callback));
-  }
-
-  /**
-   * Establish an IPv4 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The connected signal is emitted on the request when the connection has been
-   * established.
-   * The error signal is emitted on the request in case of errors during the
-   * connection.
-   *
-   * @param ip The address to which to connect to.
-   * @param port The port to which to connect to.
-   * @param req connection request
-   */
-  void Connect(std::string_view ip, unsigned int port,
-               const std::shared_ptr<TcpConnectReq>& req);
-
-  /**
-   * Establish an IPv4 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The callback is called when the connection has been established.  Errors
-   * are reported to the stream error handler.
-   *
-   * @param ip The address to which to connect to.
-   * @param port The port to which to connect to.
-   * @param callback Callback function to call when connection established
-   */
-  void Connect(std::string_view ip, unsigned int port,
-               std::function<void()> callback);
-
-  /**
-   * Establish an IPv6 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The connected signal is emitted on the request when the connection has been
-   * established.
-   * The error signal is emitted on the request in case of errors during the
-   * connection.
-   *
-   * @param ip The address to which to connect to.
-   * @param port The port to which to connect to.
-   * @param req connection request
-   */
-  void Connect6(std::string_view ip, unsigned int port,
-                const std::shared_ptr<TcpConnectReq>& req);
-
-  /**
-   * Establish an IPv6 TCP connection.
-   *
-   * On Windows if the addr is initialized to point to an unspecified address
-   * (`0.0.0.0` or `::`) it will be changed to point to localhost. This is
-   * done to match the behavior of Linux systems.
-   *
-   * The callback is called when the connection has been established.  Errors
-   * are reported to the stream error handler.
-   *
-   * @param ip The address to which to connect to.
-   * @param port The port to which to connect to.
-   * @param callback Callback function to call when connection established
-   */
-  void Connect6(std::string_view ip, unsigned int port,
-                std::function<void()> callback);
-
- private:
-  Tcp* DoAccept() override;
-
-  struct ReuseData {
-    std::function<void()> callback;
-    unsigned int flags;
-  };
-  std::unique_ptr<ReuseData> m_reuseData;
-};
-
-/**
- * TCP connection request.
- */
-class TcpConnectReq : public ConnectReq {
- public:
-  Tcp& GetStream() const {
-    return *static_cast<Tcp*>(&ConnectReq::GetStream());
-  }
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_TCP_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Timer.h b/wpiutil/src/main/native/include/wpi/uv/Timer.h
deleted file mode 100644
index 00363a5..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Timer.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_TIMER_H_
-#define WPIUTIL_WPI_UV_TIMER_H_
-
-#include <uv.h>
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Handle.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Timer handle.
- * Timer handles are used to schedule signals to be called in the future.
- */
-class Timer final : public HandleImpl<Timer, uv_timer_t> {
-  struct private_init {};
-
- public:
-  using Time = std::chrono::duration<uint64_t, std::milli>;
-
-  explicit Timer(const private_init&) {}
-  ~Timer() noexcept override = default;
-
-  /**
-   * Create a timer handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Timer> Create(Loop& loop);
-
-  /**
-   * Create a timer handle.
-   *
-   * @param loop Loop object where this handle runs.
-   */
-  static std::shared_ptr<Timer> Create(const std::shared_ptr<Loop>& loop) {
-    return Create(*loop);
-  }
-
-  /**
-   * Create a timer that calls a functor after a given time interval.
-   *
-   * @param loop Loop object where the timer should run.
-   * @param timeout Time interval
-   * @param func Functor
-   */
-  static void SingleShot(Loop& loop, Time timeout, std::function<void()> func);
-
-  /**
-   * Create a timer that calls a functor after a given time interval.
-   *
-   * @param loop Loop object where the timer should run.
-   * @param timeout Time interval
-   * @param func Functor
-   */
-  static void SingleShot(const std::shared_ptr<Loop>& loop, Time timeout,
-                         std::function<void()> func) {
-    return SingleShot(*loop, timeout, std::move(func));
-  }
-
-  /**
-   * Start the timer.
-   *
-   * If timeout is zero, an event is emitted on the next event loop
-   * iteration. If repeat is non-zero, an event is emitted first
-   * after timeout milliseconds and then repeatedly after repeat milliseconds.
-   *
-   * @param timeout Milliseconds before to emit an event (use
-   * `std::chrono::duration<uint64_t, std::milli>`).
-   * @param repeat Milliseconds between successive events (use
-   * `std::chrono::duration<uint64_t, std::milli>`).
-   */
-  void Start(Time timeout, Time repeat = Time{0});
-
-  /**
-   * Stop the timer.
-   */
-  void Stop() { Invoke(&uv_timer_stop, GetRaw()); }
-
-  /**
-   * Stop the timer and restart it if it was repeating.
-   *
-   * Stop the timer, and if it is repeating restart it using the repeat value
-   * as the timeout.
-   * If the timer has never been started before it emits sigError.
-   */
-  void Again() { Invoke(&uv_timer_again, GetRaw()); }
-
-  /**
-   * Set the repeat interval value.
-   *
-   * The timer will be scheduled to run on the given interval and will follow
-   * normal timer semantics in the case of a time-slice overrun.
-   * For example, if a 50ms repeating timer first runs for 17ms, it will be
-   * scheduled to run again 33ms later. If other tasks consume more than the
-   * 33ms following the first timer event, then another event will be emitted
-   * as soon as possible.
-   *
-   * If the repeat value is set from a listener bound to an event, it does
-   * not immediately take effect. If the timer was non-repeating before, it
-   * will have been stopped. If it was repeating, then the old repeat value
-   * will have been used to schedule the next timeout.
-   *
-   * @param repeat Repeat interval in milliseconds (use
-   * `std::chrono::duration<uint64_t, std::milli>`).
-   */
-  void SetRepeat(Time repeat) { uv_timer_set_repeat(GetRaw(), repeat.count()); }
-
-  /**
-   * Get the timer repeat value.
-   * @return Timer repeat value in milliseconds (as a
-   * `std::chrono::duration<uint64_t, std::milli>`).
-   */
-  Time GetRepeat() const { return Time{uv_timer_get_repeat(GetRaw())}; }
-
-  /**
-   * Signal generated when the timeout event occurs.
-   */
-  sig::Signal<> timeout;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_TIMER_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Tty.h b/wpiutil/src/main/native/include/wpi/uv/Tty.h
deleted file mode 100644
index bb0a6db..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Tty.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_TTY_H_
-#define WPIUTIL_WPI_UV_TTY_H_
-
-#include <uv.h>
-
-#include <memory>
-#include <utility>
-
-#include "wpi/uv/Stream.h"
-
-namespace wpi::uv {
-
-class Loop;
-class Tty;
-
-/**
- * TTY handle.
- * TTY handles represent a stream for the console.
- */
-class Tty final : public StreamImpl<Tty, uv_tty_t> {
-  struct private_init {};
-
- public:
-  explicit Tty(const private_init&) {}
-  ~Tty() noexcept override = default;
-
-  /**
-   * Create a TTY handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param fd File descriptor, usually 0=stdin, 1=stdout, 2=stderr
-   * @param readable Specifies if you plan on calling StartRead().  stdin is
-   *                 readable, stdout is not.
-   */
-  static std::shared_ptr<Tty> Create(Loop& loop, uv_file fd, bool readable);
-
-  /**
-   * Create a TTY handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param fd File descriptor, usually 0=stdin, 1=stdout, 2=stderr
-   * @param readable Specifies if you plan on calling StartRead().  stdin is
-   *                 readable, stdout is not.
-   */
-  static std::shared_ptr<Tty> Create(const std::shared_ptr<Loop>& loop,
-                                     uv_file fd, bool readable) {
-    return Create(*loop, fd, readable);
-  }
-
-  /**
-   * Set the TTY using the specified terminal mode.
-   *
-   * @param mode terminal mode
-   */
-  void SetMode(uv_tty_mode_t mode) {
-    int err = uv_tty_set_mode(GetRaw(), mode);
-    if (err < 0) {
-      ReportError(err);
-    }
-  }
-
-  /**
-   * Reset TTY settings to default values for the next process to take over.
-   * Typically called when the program exits.
-   */
-  void ResetMode() { Invoke(&uv_tty_reset_mode); }
-
-  /**
-   * Gets the current window size.
-   * @return Window size (pair of width and height).
-   */
-  std::pair<int, int> GetWindowSize() {
-    int width = 0, height = 0;
-    Invoke(&uv_tty_get_winsize, GetRaw(), &width, &height);
-    return std::make_pair(width, height);
-  }
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_TTY_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Udp.h b/wpiutil/src/main/native/include/wpi/uv/Udp.h
deleted file mode 100644
index 71fab13..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Udp.h
+++ /dev/null
@@ -1,378 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_UDP_H_
-#define WPIUTIL_WPI_UV_UDP_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/span.h"
-#include "wpi/uv/Handle.h"
-#include "wpi/uv/Request.h"
-
-namespace wpi::uv {
-
-class Loop;
-class Udp;
-
-/**
- * UDP send request.
- */
-class UdpSendReq : public RequestImpl<UdpSendReq, uv_udp_send_t> {
- public:
-  UdpSendReq();
-
-  Udp& GetUdp() const { return *static_cast<Udp*>(GetRaw()->handle->data); }
-
-  /**
-   * Send completed signal.  This is called even if an error occurred.
-   * @param err error value
-   */
-  sig::Signal<Error> complete;
-};
-
-/**
- * UDP handle.
- * UDP handles encapsulate UDP communication for both clients and servers.
- */
-class Udp final : public HandleImpl<Udp, uv_udp_t> {
-  struct private_init {};
-
- public:
-  explicit Udp(const private_init&) {}
-  ~Udp() noexcept override = default;
-
-  /**
-   * Create a UDP handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param flags Flags
-   */
-  static std::shared_ptr<Udp> Create(Loop& loop,
-                                     unsigned int flags = AF_UNSPEC);
-
-  /**
-   * Create a UDP handle.
-   *
-   * @param loop Loop object where this handle runs.
-   * @param flags Flags
-   */
-  static std::shared_ptr<Udp> Create(const std::shared_ptr<Loop>& loop,
-                                     unsigned int flags = AF_UNSPEC) {
-    return Create(*loop, flags);
-  }
-
-  /**
-   * Open an existing file descriptor or SOCKET as a UDP handle.
-   *
-   * @param sock A valid socket handle (either a file descriptor or a SOCKET).
-   */
-  void Open(uv_os_sock_t sock) { Invoke(&uv_udp_open, GetRaw(), sock); }
-
-  /**
-   * Bind the handle to an IPv4 or IPv6 address and port.
-   *
-   * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
-   * @param flags Optional additional flags.
-   */
-  void Bind(const sockaddr& addr, unsigned int flags = 0) {
-    Invoke(&uv_udp_bind, GetRaw(), &addr, flags);
-  }
-
-  void Bind(const sockaddr_in& addr, unsigned int flags = 0) {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-
-  void Bind(const sockaddr_in6& addr, unsigned int flags = 0) {
-    Bind(reinterpret_cast<const sockaddr&>(addr), flags);
-  }
-
-  /**
-   * Bind the handle to an IPv4 address and port.
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   * @param flags Optional additional flags.
-   */
-  void Bind(std::string_view ip, unsigned int port, unsigned int flags = 0);
-
-  /**
-   * Bind the handle to an IPv6 address and port.
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   * @param flags Optional additional flags.
-   */
-  void Bind6(std::string_view ip, unsigned int port, unsigned int flags = 0);
-
-  /**
-   * Associate the handle to a remote address and port, so every message sent
-   * by this handle is automatically sent to that destination.
-   *
-   * @param addr Initialized `sockaddr_in` or `sockaddr_in6` data structure.
-   */
-  void Connect(const sockaddr& addr) {
-    Invoke(&uv_udp_connect, GetRaw(), &addr);
-  }
-
-  void Connect(const sockaddr_in& addr) {
-    Connect(reinterpret_cast<const sockaddr&>(addr));
-  }
-
-  void Connect(const sockaddr_in6& addr) {
-    Connect(reinterpret_cast<const sockaddr&>(addr));
-  }
-
-  /**
-   * Associate the handle to an IPv4 address and port, so every message sent
-   * by this handle is automatically sent to that destination.
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   */
-  void Connect(std::string_view ip, unsigned int port);
-
-  /**
-   * Associate the handle to an IPv6 address and port, so every message sent
-   * by this handle is automatically sent to that destination.
-   *
-   * @param ip The address to which to bind.
-   * @param port The port to which to bind.
-   * @param flags Optional additional flags.
-   */
-  void Connect6(std::string_view ip, unsigned int port);
-
-  /**
-   * Get the remote IP and port on connected UDP handles.
-   * @return The address (will be zeroed if an error occurred).
-   */
-  sockaddr_storage GetPeer();
-
-  /**
-   * Get the current address to which the handle is bound.
-   * @return The address (will be zeroed if an error occurred).
-   */
-  sockaddr_storage GetSock();
-
-  /**
-   * Set membership for a multicast address.
-   *
-   * @param multicastAddr Multicast address to set membership for
-   * @param interfaceAddr Interface address
-   * @param membership Should be UV_JOIN_GROUP or UV_LEAVE_GROUP
-   */
-  void SetMembership(std::string_view multicastAddr,
-                     std::string_view interfaceAddr, uv_membership membership);
-
-  /**
-   * Set IP multicast loop flag.  Makes multicast packets loop back to local
-   * sockets.
-   *
-   * @param enabled True for enabled, false for disabled
-   */
-  void SetMulticastLoop(bool enabled) {
-    Invoke(&uv_udp_set_multicast_loop, GetRaw(), enabled ? 1 : 0);
-  }
-
-  /**
-   * Set the multicast TTL.
-   *
-   * @param ttl Time to live (1-255)
-   */
-  void SetMulticastTtl(int ttl) {
-    Invoke(&uv_udp_set_multicast_ttl, GetRaw(), ttl);
-  }
-
-  /**
-   * Set the multicast interface to send or receive data on.
-   *
-   * @param interfaceAddr Interface address
-   */
-  void SetMulticastInterface(std::string_view interfaceAddr);
-
-  /**
-   * Set broadcast on or off.
-   *
-   * @param enabled True for enabled, false for disabled
-   */
-  void SetBroadcast(bool enabled) {
-    Invoke(&uv_udp_set_broadcast, GetRaw(), enabled ? 1 : 0);
-  }
-
-  /**
-   * Set the time to live (TTL).
-   *
-   * @param ttl Time to live (1-255)
-   */
-  void SetTtl(int ttl) { Invoke(&uv_udp_set_ttl, GetRaw(), ttl); }
-
-  /**
-   * Send data over the UDP socket.  If the socket has not previously been bound
-   * with Bind() it will be bound to 0.0.0.0 (the "all interfaces" IPv4 address)
-   * and a random port number.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the send request.
-   * The callback can be used to free data after the request completes.
-   *
-   * HandleSendComplete() will be called on the request object when the data
-   * has been written.  HandleSendComplete() is called even if an error occurs.
-   * HandleError() will be called on the request object in case of errors.
-   *
-   * @param addr sockaddr_in or sockaddr_in6 with the address and port of the
-   *             remote peer.
-   * @param bufs The buffers to be written to the stream.
-   * @param req write request
-   */
-  void Send(const sockaddr& addr, span<const Buffer> bufs,
-            const std::shared_ptr<UdpSendReq>& req);
-
-  void Send(const sockaddr_in& addr, span<const Buffer> bufs,
-            const std::shared_ptr<UdpSendReq>& req) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, req);
-  }
-
-  void Send(const sockaddr_in6& addr, span<const Buffer> bufs,
-            const std::shared_ptr<UdpSendReq>& req) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, req);
-  }
-
-  /**
-   * Variant of Send() for connected sockets.  Cannot be used with
-   * connectionless sockets.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param req write request
-   */
-  void Send(span<const Buffer> bufs, const std::shared_ptr<UdpSendReq>& req);
-
-  /**
-   * Send data over the UDP socket.  If the socket has not previously been bound
-   * with Bind() it will be bound to 0.0.0.0 (the "all interfaces" IPv4 address)
-   * and a random port number.
-   *
-   * Data are written in order. The lifetime of the data pointers passed in
-   * the `bufs` parameter must exceed the lifetime of the send request.
-   * The callback can be used to free data after the request completes.
-   *
-   * The callback will be called when the data has been sent.  Errors will
-   * be reported via the error signal.
-   *
-   * @param addr sockaddr_in or sockaddr_in6 with the address and port of the
-   *             remote peer.
-   * @param bufs The buffers to be sent.
-   * @param callback Callback function to call when the data has been sent.
-   */
-  void Send(const sockaddr& addr, span<const Buffer> bufs,
-            std::function<void(span<Buffer>, Error)> callback);
-
-  void Send(const sockaddr_in& addr, span<const Buffer> bufs,
-            std::function<void(span<Buffer>, Error)> callback) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, std::move(callback));
-  }
-
-  void Send(const sockaddr_in6& addr, span<const Buffer> bufs,
-            std::function<void(span<Buffer>, Error)> callback) {
-    Send(reinterpret_cast<const sockaddr&>(addr), bufs, std::move(callback));
-  }
-
-  /**
-   * Variant of Send() for connected sockets.  Cannot be used with
-   * connectionless sockets.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @param callback Callback function to call when the data has been sent.
-   */
-  void Send(span<const Buffer> bufs,
-            std::function<void(span<Buffer>, Error)> callback);
-
-  /**
-   * Same as Send(), but won't queue a send request if it can't be completed
-   * immediately.
-   *
-   * @param addr sockaddr_in or sockaddr_in6 with the address and port of the
-   *             remote peer.
-   * @param bufs The buffers to be send.
-   * @return Number of bytes sent.
-   */
-  int TrySend(const sockaddr& addr, span<const Buffer> bufs) {
-    int val = uv_udp_try_send(GetRaw(), bufs.data(),
-                              static_cast<unsigned>(bufs.size()), &addr);
-    if (val < 0) {
-      this->ReportError(val);
-      return 0;
-    }
-    return val;
-  }
-
-  int TrySend(const sockaddr_in& addr, span<const Buffer> bufs) {
-    return TrySend(reinterpret_cast<const sockaddr&>(addr), bufs);
-  }
-
-  int TrySend(const sockaddr_in6& addr, span<const Buffer> bufs) {
-    return TrySend(reinterpret_cast<const sockaddr&>(addr), bufs);
-  }
-
-  /**
-   * Variant of TrySend() for connected sockets.  Cannot be used with
-   * connectionless sockets.
-   *
-   * @param bufs The buffers to be written to the stream.
-   * @return Number of bytes sent.
-   */
-  int TrySend(span<const Buffer> bufs) {
-    int val = uv_udp_try_send(GetRaw(), bufs.data(),
-                              static_cast<unsigned>(bufs.size()), nullptr);
-    if (val < 0) {
-      this->ReportError(val);
-      return 0;
-    }
-    return val;
-  }
-
-  /**
-   * Prepare for receiving data.  If the socket has not previously been bound
-   * with Bind() it is bound to 0.0.0.0 (the "all interfaces" IPv4 address) and
-   * a random port number.
-   *
-   * A received signal will be emitted for each received data packet until
-   * `StopRecv()` is called.
-   */
-  void StartRecv();
-
-  /**
-   * Stop listening for incoming datagrams.
-   */
-  void StopRecv() { Invoke(&uv_udp_recv_stop, GetRaw()); }
-
-  /**
-   * Gets the amount of queued bytes waiting to be sent.
-   * @return Amount of queued bytes waiting to be sent.
-   */
-  size_t GetSendQueueSize() const noexcept { return GetRaw()->send_queue_size; }
-
-  /**
-   * Gets the amount of queued packets waiting to be sent.
-   * @return Amount of queued packets waiting to be sent.
-   */
-  size_t GetSendQueueCount() const noexcept {
-    return GetRaw()->send_queue_count;
-  }
-
-  /**
-   * Signal generated for each incoming datagram.  Parameters are the buffer,
-   * the number of bytes received, the address of the sender, and flags.
-   */
-  sig::Signal<Buffer&, size_t, const sockaddr&, unsigned> received;
-};
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_UDP_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/Work.h b/wpiutil/src/main/native/include/wpi/uv/Work.h
deleted file mode 100644
index 5a3a5d2..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/Work.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_WORK_H_
-#define WPIUTIL_WPI_UV_WORK_H_
-
-#include <uv.h>
-
-#include <functional>
-#include <memory>
-#include <utility>
-
-#include "wpi/Signal.h"
-#include "wpi/uv/Request.h"
-
-namespace wpi::uv {
-
-class Loop;
-
-/**
- * Work request.
- * For use with `QueueWork()` function family.
- */
-class WorkReq : public RequestImpl<WorkReq, uv_work_t> {
- public:
-  WorkReq();
-
-  Loop& GetLoop() const { return *static_cast<Loop*>(GetRaw()->loop->data); }
-
-  /**
-   * Function(s) that will be run on the thread pool.
-   */
-  sig::Signal<> work;
-
-  /**
-   * Function(s) that will be run on the loop thread after the work on the
-   * thread pool has been completed by the work callback.
-   */
-  sig::Signal<> afterWork;
-};
-
-/**
- * Initializes a work request which will run on the thread pool.
- *
- * @param loop Event loop
- * @param req request
- */
-void QueueWork(Loop& loop, const std::shared_ptr<WorkReq>& req);
-
-/**
- * Initializes a work request which will run on the thread pool.
- *
- * @param loop Event loop
- * @param req request
- */
-inline void QueueWork(const std::shared_ptr<Loop>& loop,
-                      const std::shared_ptr<WorkReq>& req) {
-  QueueWork(*loop, req);
-}
-
-/**
- * Initializes a work request which will run on the thread pool.  The work
- * callback will be run on a thread from the thread pool, and the afterWork
- * callback will be called on the loop thread after the work completes.  Any
- * errors are forwarded to the loop.
- *
- * @param loop Event loop
- * @param work Work callback (called from separate thread)
- * @param afterWork After work callback (called on loop thread)
- */
-void QueueWork(Loop& loop, std::function<void()> work,
-               std::function<void()> afterWork);
-
-/**
- * Initializes a work request which will run on the thread pool.  The work
- * callback will be run on a thread from the thread pool, and the afterWork
- * callback will be called on the loop thread after the work completes.  Any
- * errors are forwarded to the loop.
- *
- * @param loop Event loop
- * @param work Work callback (called from separate thread)
- * @param afterWork After work callback (called on loop thread)
- */
-inline void QueueWork(const std::shared_ptr<Loop>& loop,
-                      std::function<void()> work,
-                      std::function<void()> afterWork) {
-  QueueWork(*loop, std::move(work), std::move(afterWork));
-}
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_WORK_H_
diff --git a/wpiutil/src/main/native/include/wpi/uv/util.h b/wpiutil/src/main/native/include/wpi/uv/util.h
deleted file mode 100644
index 01dec0b..0000000
--- a/wpiutil/src/main/native/include/wpi/uv/util.h
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef WPIUTIL_WPI_UV_UTIL_H_
-#define WPIUTIL_WPI_UV_UTIL_H_
-
-#include <uv.h>
-
-#include <cstring>
-#include <string_view>
-
-namespace wpi::uv {
-
-/**
- * Convert a binary structure containing an IPv4 address to a string.
- * @param addr Binary structure
- * @param ip Output string (any type that has `assign(char*, char*)`)
- * @param port Output port number
- * @return Error (same as `uv_ip4_name()`).
- */
-template <typename T>
-int AddrToName(const sockaddr_in& addr, T* ip, unsigned int* port) {
-  char name[128];
-  int err = uv_ip4_name(&addr, name, 128);
-  if (err == 0) {
-    ip->assign(name, name + std::strlen(name));
-    *port = ntohs(addr.sin_port);
-  } else {
-    ip->assign(name, name);
-  }
-  return err;
-}
-
-/**
- * Convert a binary structure containing an IPv6 address to a string.
- * @param addr Binary structure
- * @param ip Output string (any type that has `assign(char*, char*)`)
- * @param port Output port number
- * @return Error (same as `uv_ip6_name()`).
- */
-template <typename T>
-int AddrToName(const sockaddr_in6& addr, T* ip, unsigned int* port) {
-  char name[128];
-  int err = uv_ip6_name(&addr, name, 128);
-  if (err == 0) {
-    ip->assign(name, name + std::strlen(name));
-    *port = ntohs(addr.sin6_port);
-  } else {
-    ip->assign(name, name);
-  }
-  return err;
-}
-
-/**
- * Convert a binary structure containing an IPv4 or IPv6 address to a string.
- * @param addr Binary structure
- * @param ip Output string (any type that has `assign(char*, char*)`)
- * @param port Output port number
- * @return Error (same as `uv_ip6_name()`).
- */
-template <typename T>
-int AddrToName(const sockaddr_storage& addr, T* ip, unsigned int* port) {
-  if (addr.ss_family == AF_INET) {
-    return AddrToName(reinterpret_cast<const sockaddr_in&>(addr), ip, port);
-  }
-  if (addr.ss_family == AF_INET6) {
-    return AddrToName(reinterpret_cast<const sockaddr_in6&>(addr), ip, port);
-  }
-  char name[1];
-  ip->assign(name, name);
-  return -1;
-}
-
-/**
- * Convert a binary IPv4 address to a string.
- * @param addr Binary address
- * @param ip Output string (any type that has `assign(char*, char*)`)
- * @return Error (same as `uv_inet_ntop()`).
- */
-template <typename T>
-int AddrToName(const in_addr& addr, T* ip) {
-  char name[128];
-  int err = uv_inet_ntop(AF_INET, &addr, name, 128);
-  if (err == 0) {
-    ip->assign(name, name + std::strlen(name));
-  } else {
-    ip->assign(name, name);
-  }
-  return err;
-}
-
-/**
- * Convert a binary IPv6 address to a string.
- * @param addr Binary address
- * @param ip Output string (any type that has `assign(char*, char*)`)
- * @return Error (same as `uv_inet_ntop()`).
- */
-template <typename T>
-int AddrToName(const in6_addr& addr, T* ip) {
-  char name[128];
-  int err = uv_inet_ntop(AF_INET6, &addr, name, 128);
-  if (err == 0) {
-    ip->assign(name, name + std::strlen(name));
-  } else {
-    ip->assign(name, name);
-  }
-  return err;
-}
-
-/**
- * Convert a string containing an IPv4 address to a binary structure.
- * @param ip IPv4 address string
- * @param port Port number
- * @param addr Output binary structure
- * @return Error (same as `uv_ip4_addr()`).
- */
-int NameToAddr(std::string_view ip, unsigned int port, sockaddr_in* addr);
-
-/**
- * Convert a string containing an IPv6 address to a binary structure.
- * @param ip IPv6 address string
- * @param port Port number
- * @param addr Output binary structure
- * @return Error (same as `uv_ip6_addr()`).
- */
-int NameToAddr(std::string_view ip, unsigned int port, sockaddr_in6* addr);
-
-/**
- * Convert a string containing an IPv4 address to binary format.
- * @param ip IPv4 address string
- * @param addr Output binary
- * @return Error (same as `uv_inet_pton()`).
- */
-int NameToAddr(std::string_view ip, in_addr* addr);
-
-/**
- * Convert a string containing an IPv6 address to binary format.
- * @param ip IPv6 address string
- * @param addr Output binary
- * @return Error (same as `uv_inet_pton()`).
- */
-int NameToAddr(std::string_view ip, in6_addr* addr);
-
-}  // namespace wpi::uv
-
-#endif  // WPIUTIL_WPI_UV_UTIL_H_
diff --git a/wpiutil/src/main/native/libuv/include/uv.h b/wpiutil/src/main/native/libuv/include/uv.h
deleted file mode 100644
index ccf62c8..0000000
--- a/wpiutil/src/main/native/libuv/include/uv.h
+++ /dev/null
@@ -1,1683 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-/* See https://github.com/libuv/libuv#documentation for documentation. */
-
-#ifndef UV_H
-#define UV_H
-
-#ifdef _WIN32
-  /* Windows - set up dll import/export decorators. */
-# if defined(BUILDING_UV_SHARED)
-    /* Building shared library. */
-#   define UV_EXTERN __declspec(dllexport)
-# elif defined(USING_UV_SHARED)
-    /* Using shared library. */
-#   define UV_EXTERN __declspec(dllimport)
-# else
-    /* Building static library. */
-#   define UV_EXTERN /* nothing */
-# endif
-#elif __GNUC__ >= 4
-# define UV_EXTERN __attribute__((visibility("default")))
-#else
-# define UV_EXTERN /* nothing */
-#endif
-
-#include "uv/errno.h"
-#include "uv/version.h"
-#include <stddef.h>
-#include <stdio.h>
-
-#include <stdint.h>
-
-#if defined(_WIN32)
-# include "uv/win.h"
-#else
-# include "uv/unix.h"
-#endif
-
-/* Expand this list if necessary. */
-#define UV_ERRNO_MAP(XX)                                                      \
-  XX(E2BIG, "argument list too long")                                         \
-  XX(EACCES, "permission denied")                                             \
-  XX(EADDRINUSE, "address already in use")                                    \
-  XX(EADDRNOTAVAIL, "address not available")                                  \
-  XX(EAFNOSUPPORT, "address family not supported")                            \
-  XX(EAGAIN, "resource temporarily unavailable")                              \
-  XX(EAI_ADDRFAMILY, "address family not supported")                          \
-  XX(EAI_AGAIN, "temporary failure")                                          \
-  XX(EAI_BADFLAGS, "bad ai_flags value")                                      \
-  XX(EAI_BADHINTS, "invalid value for hints")                                 \
-  XX(EAI_CANCELED, "request canceled")                                        \
-  XX(EAI_FAIL, "permanent failure")                                           \
-  XX(EAI_FAMILY, "ai_family not supported")                                   \
-  XX(EAI_MEMORY, "out of memory")                                             \
-  XX(EAI_NODATA, "no address")                                                \
-  XX(EAI_NONAME, "unknown node or service")                                   \
-  XX(EAI_OVERFLOW, "argument buffer overflow")                                \
-  XX(EAI_PROTOCOL, "resolved protocol is unknown")                            \
-  XX(EAI_SERVICE, "service not available for socket type")                    \
-  XX(EAI_SOCKTYPE, "socket type not supported")                               \
-  XX(EALREADY, "connection already in progress")                              \
-  XX(EBADF, "bad file descriptor")                                            \
-  XX(EBUSY, "resource busy or locked")                                        \
-  XX(ECANCELED, "operation canceled")                                         \
-  XX(ECHARSET, "invalid Unicode character")                                   \
-  XX(ECONNABORTED, "software caused connection abort")                        \
-  XX(ECONNREFUSED, "connection refused")                                      \
-  XX(ECONNRESET, "connection reset by peer")                                  \
-  XX(EDESTADDRREQ, "destination address required")                            \
-  XX(EEXIST, "file already exists")                                           \
-  XX(EFAULT, "bad address in system call argument")                           \
-  XX(EFBIG, "file too large")                                                 \
-  XX(EHOSTUNREACH, "host is unreachable")                                     \
-  XX(EINTR, "interrupted system call")                                        \
-  XX(EINVAL, "invalid argument")                                              \
-  XX(EIO, "i/o error")                                                        \
-  XX(EISCONN, "socket is already connected")                                  \
-  XX(EISDIR, "illegal operation on a directory")                              \
-  XX(ELOOP, "too many symbolic links encountered")                            \
-  XX(EMFILE, "too many open files")                                           \
-  XX(EMSGSIZE, "message too long")                                            \
-  XX(ENAMETOOLONG, "name too long")                                           \
-  XX(ENETDOWN, "network is down")                                             \
-  XX(ENETUNREACH, "network is unreachable")                                   \
-  XX(ENFILE, "file table overflow")                                           \
-  XX(ENOBUFS, "no buffer space available")                                    \
-  XX(ENODEV, "no such device")                                                \
-  XX(ENOENT, "no such file or directory")                                     \
-  XX(ENOMEM, "not enough memory")                                             \
-  XX(ENONET, "machine is not on the network")                                 \
-  XX(ENOPROTOOPT, "protocol not available")                                   \
-  XX(ENOSPC, "no space left on device")                                       \
-  XX(ENOSYS, "function not implemented")                                      \
-  XX(ENOTCONN, "socket is not connected")                                     \
-  XX(ENOTDIR, "not a directory")                                              \
-  XX(ENOTEMPTY, "directory not empty")                                        \
-  XX(ENOTSOCK, "socket operation on non-socket")                              \
-  XX(ENOTSUP, "operation not supported on socket")                            \
-  XX(EPERM, "operation not permitted")                                        \
-  XX(EPIPE, "broken pipe")                                                    \
-  XX(EPROTO, "protocol error")                                                \
-  XX(EPROTONOSUPPORT, "protocol not supported")                               \
-  XX(EPROTOTYPE, "protocol wrong type for socket")                            \
-  XX(ERANGE, "result too large")                                              \
-  XX(EROFS, "read-only file system")                                          \
-  XX(ESHUTDOWN, "cannot send after transport endpoint shutdown")              \
-  XX(ESPIPE, "invalid seek")                                                  \
-  XX(ESRCH, "no such process")                                                \
-  XX(ETIMEDOUT, "connection timed out")                                       \
-  XX(ETXTBSY, "text file is busy")                                            \
-  XX(EXDEV, "cross-device link not permitted")                                \
-  XX(UNKNOWN, "unknown error")                                                \
-  XX(EOF, "end of file")                                                      \
-  XX(ENXIO, "no such device or address")                                      \
-  XX(EMLINK, "too many links")                                                \
-  XX(EHOSTDOWN, "host is down")                                               \
-  XX(EREMOTEIO, "remote I/O error")                                           \
-  XX(ENOTTY, "inappropriate ioctl for device")                                \
-  XX(EFTYPE, "inappropriate file type or format")                             \
-
-#define UV_HANDLE_TYPE_MAP(XX)                                                \
-  XX(ASYNC, async)                                                            \
-  XX(CHECK, check)                                                            \
-  XX(FS_EVENT, fs_event)                                                      \
-  XX(FS_POLL, fs_poll)                                                        \
-  XX(HANDLE, handle)                                                          \
-  XX(IDLE, idle)                                                              \
-  XX(NAMED_PIPE, pipe)                                                        \
-  XX(POLL, poll)                                                              \
-  XX(PREPARE, prepare)                                                        \
-  XX(PROCESS, process)                                                        \
-  XX(STREAM, stream)                                                          \
-  XX(TCP, tcp)                                                                \
-  XX(TIMER, timer)                                                            \
-  XX(TTY, tty)                                                                \
-  XX(UDP, udp)                                                                \
-  XX(SIGNAL, signal)                                                          \
-
-#define UV_REQ_TYPE_MAP(XX)                                                   \
-  XX(REQ, req)                                                                \
-  XX(CONNECT, connect)                                                        \
-  XX(WRITE, write)                                                            \
-  XX(SHUTDOWN, shutdown)                                                      \
-  XX(UDP_SEND, udp_send)                                                      \
-  XX(FS, fs)                                                                  \
-  XX(WORK, work)                                                              \
-  XX(GETADDRINFO, getaddrinfo)                                                \
-  XX(GETNAMEINFO, getnameinfo)                                                \
-
-typedef enum {
-#define XX(code, _) UV_ ## code = UV__ ## code,
-  UV_ERRNO_MAP(XX)
-#undef XX
-  UV_ERRNO_MAX = UV__EOF - 1
-} uv_errno_t;
-
-typedef enum {
-  UV_UNKNOWN_HANDLE = 0,
-#define XX(uc, lc) UV_##uc,
-  UV_HANDLE_TYPE_MAP(XX)
-#undef XX
-  UV_FILE,
-  UV_HANDLE_TYPE_MAX
-} uv_handle_type;
-
-typedef enum {
-  UV_UNKNOWN_REQ = 0,
-#define XX(uc, lc) UV_##uc,
-  UV_REQ_TYPE_MAP(XX)
-#undef XX
-  UV_REQ_TYPE_PRIVATE
-  UV_REQ_TYPE_MAX
-} uv_req_type;
-
-
-/* Handle types. */
-typedef struct uv_loop_s uv_loop_t;
-typedef struct uv_handle_s uv_handle_t;
-typedef struct uv_dir_s uv_dir_t;
-typedef struct uv_stream_s uv_stream_t;
-typedef struct uv_tcp_s uv_tcp_t;
-typedef struct uv_udp_s uv_udp_t;
-typedef struct uv_pipe_s uv_pipe_t;
-typedef struct uv_tty_s uv_tty_t;
-typedef struct uv_poll_s uv_poll_t;
-typedef struct uv_timer_s uv_timer_t;
-typedef struct uv_prepare_s uv_prepare_t;
-typedef struct uv_check_s uv_check_t;
-typedef struct uv_idle_s uv_idle_t;
-typedef struct uv_async_s uv_async_t;
-typedef struct uv_process_s uv_process_t;
-typedef struct uv_fs_event_s uv_fs_event_t;
-typedef struct uv_fs_poll_s uv_fs_poll_t;
-typedef struct uv_signal_s uv_signal_t;
-
-/* Request types. */
-typedef struct uv_req_s uv_req_t;
-typedef struct uv_getaddrinfo_s uv_getaddrinfo_t;
-typedef struct uv_getnameinfo_s uv_getnameinfo_t;
-typedef struct uv_shutdown_s uv_shutdown_t;
-typedef struct uv_write_s uv_write_t;
-typedef struct uv_connect_s uv_connect_t;
-typedef struct uv_udp_send_s uv_udp_send_t;
-typedef struct uv_fs_s uv_fs_t;
-typedef struct uv_work_s uv_work_t;
-
-/* None of the above. */
-typedef struct uv_cpu_info_s uv_cpu_info_t;
-typedef struct uv_interface_address_s uv_interface_address_t;
-typedef struct uv_dirent_s uv_dirent_t;
-typedef struct uv_passwd_s uv_passwd_t;
-typedef struct uv_utsname_s uv_utsname_t;
-
-typedef enum {
-  UV_LOOP_BLOCK_SIGNAL
-} uv_loop_option;
-
-typedef enum {
-  UV_RUN_DEFAULT = 0,
-  UV_RUN_ONCE,
-  UV_RUN_NOWAIT
-} uv_run_mode;
-
-
-UV_EXTERN unsigned int uv_version(void);
-UV_EXTERN const char* uv_version_string(void);
-
-typedef void* (*uv_malloc_func)(size_t size);
-typedef void* (*uv_realloc_func)(void* ptr, size_t size);
-typedef void* (*uv_calloc_func)(size_t count, size_t size);
-typedef void (*uv_free_func)(void* ptr);
-
-UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func,
-                                   uv_realloc_func realloc_func,
-                                   uv_calloc_func calloc_func,
-                                   uv_free_func free_func);
-
-UV_EXTERN uv_loop_t* uv_default_loop(void);
-UV_EXTERN int uv_loop_init(uv_loop_t* loop);
-UV_EXTERN int uv_loop_close(uv_loop_t* loop);
-/*
- * NOTE:
- *  This function is DEPRECATED (to be removed after 0.12), users should
- *  allocate the loop manually and use uv_loop_init instead.
- */
-UV_EXTERN uv_loop_t* uv_loop_new(void);
-/*
- * NOTE:
- *  This function is DEPRECATED (to be removed after 0.12). Users should use
- *  uv_loop_close and free the memory manually instead.
- */
-UV_EXTERN void uv_loop_delete(uv_loop_t*);
-UV_EXTERN size_t uv_loop_size(void);
-UV_EXTERN int uv_loop_alive(const uv_loop_t* loop);
-UV_EXTERN int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...);
-UV_EXTERN int uv_loop_fork(uv_loop_t* loop);
-
-UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode);
-UV_EXTERN void uv_stop(uv_loop_t*);
-
-UV_EXTERN void uv_ref(uv_handle_t*);
-UV_EXTERN void uv_unref(uv_handle_t*);
-UV_EXTERN int uv_has_ref(const uv_handle_t*);
-
-UV_EXTERN void uv_update_time(uv_loop_t*);
-UV_EXTERN uint64_t uv_now(const uv_loop_t*);
-
-UV_EXTERN int uv_backend_fd(const uv_loop_t*);
-UV_EXTERN int uv_backend_timeout(const uv_loop_t*);
-
-typedef void (*uv_alloc_cb)(uv_handle_t* handle,
-                            size_t suggested_size,
-                            uv_buf_t* buf);
-typedef void (*uv_read_cb)(uv_stream_t* stream,
-                           ssize_t nread,
-                           const uv_buf_t* buf);
-typedef void (*uv_write_cb)(uv_write_t* req, int status);
-typedef void (*uv_connect_cb)(uv_connect_t* req, int status);
-typedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status);
-typedef void (*uv_connection_cb)(uv_stream_t* server, int status);
-typedef void (*uv_close_cb)(uv_handle_t* handle);
-typedef void (*uv_poll_cb)(uv_poll_t* handle, int status, int events);
-typedef void (*uv_timer_cb)(uv_timer_t* handle);
-typedef void (*uv_async_cb)(uv_async_t* handle);
-typedef void (*uv_prepare_cb)(uv_prepare_t* handle);
-typedef void (*uv_check_cb)(uv_check_t* handle);
-typedef void (*uv_idle_cb)(uv_idle_t* handle);
-typedef void (*uv_exit_cb)(uv_process_t*, int64_t exit_status, int term_signal);
-typedef void (*uv_walk_cb)(uv_handle_t* handle, void* arg);
-typedef void (*uv_fs_cb)(uv_fs_t* req);
-typedef void (*uv_work_cb)(uv_work_t* req);
-typedef void (*uv_after_work_cb)(uv_work_t* req, int status);
-typedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req,
-                                  int status,
-                                  struct addrinfo* res);
-typedef void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req,
-                                  int status,
-                                  const char* hostname,
-                                  const char* service);
-
-typedef struct {
-  long tv_sec;
-  long tv_nsec;
-} uv_timespec_t;
-
-
-typedef struct {
-  uint64_t st_dev;
-  uint64_t st_mode;
-  uint64_t st_nlink;
-  uint64_t st_uid;
-  uint64_t st_gid;
-  uint64_t st_rdev;
-  uint64_t st_ino;
-  uint64_t st_size;
-  uint64_t st_blksize;
-  uint64_t st_blocks;
-  uint64_t st_flags;
-  uint64_t st_gen;
-  uv_timespec_t st_atim;
-  uv_timespec_t st_mtim;
-  uv_timespec_t st_ctim;
-  uv_timespec_t st_birthtim;
-} uv_stat_t;
-
-
-typedef void (*uv_fs_event_cb)(uv_fs_event_t* handle,
-                               const char* filename,
-                               int events,
-                               int status);
-
-typedef void (*uv_fs_poll_cb)(uv_fs_poll_t* handle,
-                              int status,
-                              const uv_stat_t* prev,
-                              const uv_stat_t* curr);
-
-typedef void (*uv_signal_cb)(uv_signal_t* handle, int signum);
-
-
-typedef enum {
-  UV_LEAVE_GROUP = 0,
-  UV_JOIN_GROUP
-} uv_membership;
-
-
-UV_EXTERN int uv_translate_sys_error(int sys_errno);
-
-UV_EXTERN const char* uv_strerror(int err);
-UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen);
-
-UV_EXTERN const char* uv_err_name(int err);
-UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen);
-
-
-#define UV_REQ_FIELDS                                                         \
-  /* public */                                                                \
-  void* data;                                                                 \
-  /* read-only */                                                             \
-  uv_req_type type;                                                           \
-  /* private */                                                               \
-  void* reserved[6];                                                          \
-  UV_REQ_PRIVATE_FIELDS                                                       \
-
-/* Abstract base class of all requests. */
-struct uv_req_s {
-  UV_REQ_FIELDS
-};
-
-
-/* Platform-specific request types. */
-UV_PRIVATE_REQ_TYPES
-
-
-UV_EXTERN int uv_shutdown(uv_shutdown_t* req,
-                          uv_stream_t* handle,
-                          uv_shutdown_cb cb);
-
-struct uv_shutdown_s {
-  UV_REQ_FIELDS
-  uv_stream_t* handle;
-  uv_shutdown_cb cb;
-  UV_SHUTDOWN_PRIVATE_FIELDS
-};
-
-
-#define UV_HANDLE_FIELDS                                                      \
-  /* public */                                                                \
-  void* data;                                                                 \
-  /* read-only */                                                             \
-  uv_loop_t* loop;                                                            \
-  uv_handle_type type;                                                        \
-  /* private */                                                               \
-  uv_close_cb close_cb;                                                       \
-  void* handle_queue[2];                                                      \
-  union {                                                                     \
-    int fd;                                                                   \
-    void* reserved[4];                                                        \
-  } u;                                                                        \
-  UV_HANDLE_PRIVATE_FIELDS                                                    \
-
-/* The abstract base class of all handles. */
-struct uv_handle_s {
-  UV_HANDLE_FIELDS
-};
-
-UV_EXTERN size_t uv_handle_size(uv_handle_type type);
-UV_EXTERN uv_handle_type uv_handle_get_type(const uv_handle_t* handle);
-UV_EXTERN const char* uv_handle_type_name(uv_handle_type type);
-UV_EXTERN void* uv_handle_get_data(const uv_handle_t* handle);
-UV_EXTERN uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle);
-UV_EXTERN void uv_handle_set_data(uv_handle_t* handle, void* data);
-
-UV_EXTERN size_t uv_req_size(uv_req_type type);
-UV_EXTERN void* uv_req_get_data(const uv_req_t* req);
-UV_EXTERN void uv_req_set_data(uv_req_t* req, void* data);
-UV_EXTERN uv_req_type uv_req_get_type(const uv_req_t* req);
-UV_EXTERN const char* uv_req_type_name(uv_req_type type);
-
-UV_EXTERN int uv_is_active(const uv_handle_t* handle);
-
-UV_EXTERN void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg);
-
-/* Helpers for ad hoc debugging, no API/ABI stability guaranteed. */
-UV_EXTERN void uv_print_all_handles(uv_loop_t* loop, FILE* stream);
-UV_EXTERN void uv_print_active_handles(uv_loop_t* loop, FILE* stream);
-
-UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb);
-
-UV_EXTERN int uv_send_buffer_size(uv_handle_t* handle, int* value);
-UV_EXTERN int uv_recv_buffer_size(uv_handle_t* handle, int* value);
-
-UV_EXTERN int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd);
-
-UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len);
-
-
-#define UV_STREAM_FIELDS                                                      \
-  /* number of bytes queued for writing */                                    \
-  size_t write_queue_size;                                                    \
-  uv_alloc_cb alloc_cb;                                                       \
-  uv_read_cb read_cb;                                                         \
-  /* private */                                                               \
-  UV_STREAM_PRIVATE_FIELDS
-
-/*
- * uv_stream_t is a subclass of uv_handle_t.
- *
- * uv_stream is an abstract class.
- *
- * uv_stream_t is the parent class of uv_tcp_t, uv_pipe_t and uv_tty_t.
- */
-struct uv_stream_s {
-  UV_HANDLE_FIELDS
-  UV_STREAM_FIELDS
-};
-
-UV_EXTERN size_t uv_stream_get_write_queue_size(const uv_stream_t* stream);
-
-UV_EXTERN int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb);
-UV_EXTERN int uv_accept(uv_stream_t* server, uv_stream_t* client);
-
-UV_EXTERN int uv_read_start(uv_stream_t*,
-                            uv_alloc_cb alloc_cb,
-                            uv_read_cb read_cb);
-UV_EXTERN int uv_read_stop(uv_stream_t*);
-
-UV_EXTERN int uv_write(uv_write_t* req,
-                       uv_stream_t* handle,
-                       const uv_buf_t bufs[],
-                       unsigned int nbufs,
-                       uv_write_cb cb);
-UV_EXTERN int uv_write2(uv_write_t* req,
-                        uv_stream_t* handle,
-                        const uv_buf_t bufs[],
-                        unsigned int nbufs,
-                        uv_stream_t* send_handle,
-                        uv_write_cb cb);
-UV_EXTERN int uv_try_write(uv_stream_t* handle,
-                           const uv_buf_t bufs[],
-                           unsigned int nbufs);
-
-/* uv_write_t is a subclass of uv_req_t. */
-struct uv_write_s {
-  UV_REQ_FIELDS
-  uv_write_cb cb;
-  uv_stream_t* send_handle; /* TODO: make private and unix-only in v2.x. */
-  uv_stream_t* handle;
-  UV_WRITE_PRIVATE_FIELDS
-};
-
-
-UV_EXTERN int uv_is_readable(const uv_stream_t* handle);
-UV_EXTERN int uv_is_writable(const uv_stream_t* handle);
-
-UV_EXTERN int uv_stream_set_blocking(uv_stream_t* handle, int blocking);
-
-UV_EXTERN int uv_is_closing(const uv_handle_t* handle);
-
-
-/*
- * uv_tcp_t is a subclass of uv_stream_t.
- *
- * Represents a TCP stream or TCP server.
- */
-struct uv_tcp_s {
-  UV_HANDLE_FIELDS
-  UV_STREAM_FIELDS
-  UV_TCP_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_tcp_init(uv_loop_t*, uv_tcp_t* handle);
-UV_EXTERN int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags);
-UV_EXTERN int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock);
-UV_EXTERN int uv_tcp_nodelay(uv_tcp_t* handle, int enable);
-UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle,
-                               int enable,
-                               unsigned int delay);
-UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable);
-
-enum uv_tcp_flags {
-  /* Used with uv_tcp_bind, when an IPv6 address is used. */
-  UV_TCP_IPV6ONLY = 1
-};
-
-UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle,
-                          const struct sockaddr* addr,
-                          unsigned int flags);
-UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle,
-                                 struct sockaddr* name,
-                                 int* namelen);
-UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle,
-                                 struct sockaddr* name,
-                                 int* namelen);
-UV_EXTERN int uv_tcp_connect(uv_connect_t* req,
-                             uv_tcp_t* handle,
-                             const struct sockaddr* addr,
-                             uv_connect_cb cb);
-
-/* uv_connect_t is a subclass of uv_req_t. */
-struct uv_connect_s {
-  UV_REQ_FIELDS
-  uv_connect_cb cb;
-  uv_stream_t* handle;
-  UV_CONNECT_PRIVATE_FIELDS
-};
-
-
-/*
- * UDP support.
- */
-
-enum uv_udp_flags {
-  /* Disables dual stack mode. */
-  UV_UDP_IPV6ONLY = 1,
-  /*
-   * Indicates message was truncated because read buffer was too small. The
-   * remainder was discarded by the OS. Used in uv_udp_recv_cb.
-   */
-  UV_UDP_PARTIAL = 2,
-  /*
-   * Indicates if SO_REUSEADDR will be set when binding the handle.
-   * This sets the SO_REUSEPORT socket flag on the BSDs and OS X. On other
-   * Unix platforms, it sets the SO_REUSEADDR flag.  What that means is that
-   * multiple threads or processes can bind to the same address without error
-   * (provided they all set the flag) but only the last one to bind will receive
-   * any traffic, in effect "stealing" the port from the previous listener.
-   */
-  UV_UDP_REUSEADDR = 4
-};
-
-typedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status);
-typedef void (*uv_udp_recv_cb)(uv_udp_t* handle,
-                               ssize_t nread,
-                               const uv_buf_t* buf,
-                               const struct sockaddr* addr,
-                               unsigned flags);
-
-/* uv_udp_t is a subclass of uv_handle_t. */
-struct uv_udp_s {
-  UV_HANDLE_FIELDS
-  /* read-only */
-  /*
-   * Number of bytes queued for sending. This field strictly shows how much
-   * information is currently queued.
-   */
-  size_t send_queue_size;
-  /*
-   * Number of send requests currently in the queue awaiting to be processed.
-   */
-  size_t send_queue_count;
-  UV_UDP_PRIVATE_FIELDS
-};
-
-/* uv_udp_send_t is a subclass of uv_req_t. */
-struct uv_udp_send_s {
-  UV_REQ_FIELDS
-  uv_udp_t* handle;
-  uv_udp_send_cb cb;
-  UV_UDP_SEND_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_udp_init(uv_loop_t*, uv_udp_t* handle);
-UV_EXTERN int uv_udp_init_ex(uv_loop_t*, uv_udp_t* handle, unsigned int flags);
-UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock);
-UV_EXTERN int uv_udp_bind(uv_udp_t* handle,
-                          const struct sockaddr* addr,
-                          unsigned int flags);
-UV_EXTERN int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr);
-
-UV_EXTERN int uv_udp_getpeername(const uv_udp_t* handle,
-                                 struct sockaddr* name,
-                                 int* namelen);
-UV_EXTERN int uv_udp_getsockname(const uv_udp_t* handle,
-                                 struct sockaddr* name,
-                                 int* namelen);
-UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle,
-                                    const char* multicast_addr,
-                                    const char* interface_addr,
-                                    uv_membership membership);
-UV_EXTERN int uv_udp_set_multicast_loop(uv_udp_t* handle, int on);
-UV_EXTERN int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl);
-UV_EXTERN int uv_udp_set_multicast_interface(uv_udp_t* handle,
-                                             const char* interface_addr);
-UV_EXTERN int uv_udp_set_broadcast(uv_udp_t* handle, int on);
-UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl);
-UV_EXTERN int uv_udp_send(uv_udp_send_t* req,
-                          uv_udp_t* handle,
-                          const uv_buf_t bufs[],
-                          unsigned int nbufs,
-                          const struct sockaddr* addr,
-                          uv_udp_send_cb send_cb);
-UV_EXTERN int uv_udp_try_send(uv_udp_t* handle,
-                              const uv_buf_t bufs[],
-                              unsigned int nbufs,
-                              const struct sockaddr* addr);
-UV_EXTERN int uv_udp_recv_start(uv_udp_t* handle,
-                                uv_alloc_cb alloc_cb,
-                                uv_udp_recv_cb recv_cb);
-UV_EXTERN int uv_udp_recv_stop(uv_udp_t* handle);
-UV_EXTERN size_t uv_udp_get_send_queue_size(const uv_udp_t* handle);
-UV_EXTERN size_t uv_udp_get_send_queue_count(const uv_udp_t* handle);
-
-
-/*
- * uv_tty_t is a subclass of uv_stream_t.
- *
- * Representing a stream for the console.
- */
-struct uv_tty_s {
-  UV_HANDLE_FIELDS
-  UV_STREAM_FIELDS
-  UV_TTY_PRIVATE_FIELDS
-};
-
-typedef enum {
-  /* Initial/normal terminal mode */
-  UV_TTY_MODE_NORMAL,
-  /* Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled) */
-  UV_TTY_MODE_RAW,
-  /* Binary-safe I/O mode for IPC (Unix-only) */
-  UV_TTY_MODE_IO
-} uv_tty_mode_t;
-
-UV_EXTERN int uv_tty_init(uv_loop_t*, uv_tty_t*, uv_file fd, int readable);
-UV_EXTERN int uv_tty_set_mode(uv_tty_t*, uv_tty_mode_t mode);
-UV_EXTERN int uv_tty_reset_mode(void);
-UV_EXTERN int uv_tty_get_winsize(uv_tty_t*, int* width, int* height);
-
-inline int uv_tty_set_mode(uv_tty_t* handle, int mode) {
-  return uv_tty_set_mode(handle, static_cast<uv_tty_mode_t>(mode));
-}
-
-UV_EXTERN uv_handle_type uv_guess_handle(uv_file file);
-
-/*
- * uv_pipe_t is a subclass of uv_stream_t.
- *
- * Representing a pipe stream or pipe server. On Windows this is a Named
- * Pipe. On Unix this is a Unix domain socket.
- */
-struct uv_pipe_s {
-  UV_HANDLE_FIELDS
-  UV_STREAM_FIELDS
-  int ipc; /* non-zero if this pipe is used for passing handles */
-  UV_PIPE_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc);
-UV_EXTERN int uv_pipe_open(uv_pipe_t*, uv_file file);
-UV_EXTERN int uv_pipe_bind(uv_pipe_t* handle, const char* name);
-UV_EXTERN void uv_pipe_connect(uv_connect_t* req,
-                               uv_pipe_t* handle,
-                               const char* name,
-                               uv_connect_cb cb);
-UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle,
-                                  char* buffer,
-                                  size_t* size);
-UV_EXTERN int uv_pipe_getpeername(const uv_pipe_t* handle,
-                                  char* buffer,
-                                  size_t* size);
-UV_EXTERN void uv_pipe_pending_instances(uv_pipe_t* handle, int count);
-UV_EXTERN int uv_pipe_pending_count(uv_pipe_t* handle);
-UV_EXTERN uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle);
-UV_EXTERN int uv_pipe_chmod(uv_pipe_t* handle, int flags);
-
-
-struct uv_poll_s {
-  UV_HANDLE_FIELDS
-  uv_poll_cb poll_cb;
-  UV_POLL_PRIVATE_FIELDS
-};
-
-enum uv_poll_event {
-  UV_READABLE = 1,
-  UV_WRITABLE = 2,
-  UV_DISCONNECT = 4,
-  UV_PRIORITIZED = 8
-};
-
-UV_EXTERN int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd);
-UV_EXTERN int uv_poll_init_socket(uv_loop_t* loop,
-                                  uv_poll_t* handle,
-                                  uv_os_sock_t socket);
-UV_EXTERN int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb);
-UV_EXTERN int uv_poll_stop(uv_poll_t* handle);
-
-
-struct uv_prepare_s {
-  UV_HANDLE_FIELDS
-  UV_PREPARE_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_prepare_init(uv_loop_t*, uv_prepare_t* prepare);
-UV_EXTERN int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb);
-UV_EXTERN int uv_prepare_stop(uv_prepare_t* prepare);
-
-
-struct uv_check_s {
-  UV_HANDLE_FIELDS
-  UV_CHECK_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_check_init(uv_loop_t*, uv_check_t* check);
-UV_EXTERN int uv_check_start(uv_check_t* check, uv_check_cb cb);
-UV_EXTERN int uv_check_stop(uv_check_t* check);
-
-
-struct uv_idle_s {
-  UV_HANDLE_FIELDS
-  UV_IDLE_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_idle_init(uv_loop_t*, uv_idle_t* idle);
-UV_EXTERN int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb);
-UV_EXTERN int uv_idle_stop(uv_idle_t* idle);
-
-
-struct uv_async_s {
-  UV_HANDLE_FIELDS
-  UV_ASYNC_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_async_init(uv_loop_t*,
-                            uv_async_t* async,
-                            uv_async_cb async_cb);
-UV_EXTERN int uv_async_send(uv_async_t* async);
-
-
-/*
- * uv_timer_t is a subclass of uv_handle_t.
- *
- * Used to get woken up at a specified time in the future.
- */
-struct uv_timer_s {
-  UV_HANDLE_FIELDS
-  UV_TIMER_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_timer_init(uv_loop_t*, uv_timer_t* handle);
-UV_EXTERN int uv_timer_start(uv_timer_t* handle,
-                             uv_timer_cb cb,
-                             uint64_t timeout,
-                             uint64_t repeat);
-UV_EXTERN int uv_timer_stop(uv_timer_t* handle);
-UV_EXTERN int uv_timer_again(uv_timer_t* handle);
-UV_EXTERN void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat);
-UV_EXTERN uint64_t uv_timer_get_repeat(const uv_timer_t* handle);
-
-
-/*
- * uv_getaddrinfo_t is a subclass of uv_req_t.
- *
- * Request object for uv_getaddrinfo.
- */
-struct uv_getaddrinfo_s {
-  UV_REQ_FIELDS
-  /* read-only */
-  uv_loop_t* loop;
-  /* struct addrinfo* addrinfo is marked as private, but it really isn't. */
-  UV_GETADDRINFO_PRIVATE_FIELDS
-};
-
-
-UV_EXTERN int uv_getaddrinfo(uv_loop_t* loop,
-                             uv_getaddrinfo_t* req,
-                             uv_getaddrinfo_cb getaddrinfo_cb,
-                             const char* node,
-                             const char* service,
-                             const struct addrinfo* hints);
-UV_EXTERN void uv_freeaddrinfo(struct addrinfo* ai);
-
-
-/*
-* uv_getnameinfo_t is a subclass of uv_req_t.
-*
-* Request object for uv_getnameinfo.
-*/
-struct uv_getnameinfo_s {
-  UV_REQ_FIELDS
-  /* read-only */
-  uv_loop_t* loop;
-  /* host and service are marked as private, but they really aren't. */
-  UV_GETNAMEINFO_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_getnameinfo(uv_loop_t* loop,
-                             uv_getnameinfo_t* req,
-                             uv_getnameinfo_cb getnameinfo_cb,
-                             const struct sockaddr* addr,
-                             int flags);
-
-
-/* uv_spawn() options. */
-typedef enum {
-  UV_IGNORE         = 0x00,
-  UV_CREATE_PIPE    = 0x01,
-  UV_INHERIT_FD     = 0x02,
-  UV_INHERIT_STREAM = 0x04,
-
-  /*
-   * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE
-   * determine the direction of flow, from the child process' perspective. Both
-   * flags may be specified to create a duplex data stream.
-   */
-  UV_READABLE_PIPE  = 0x10,
-  UV_WRITABLE_PIPE  = 0x20,
-
-  /*
-   * Open the child pipe handle in overlapped mode on Windows.
-   * On Unix it is silently ignored.
-   */
-  UV_OVERLAPPED_PIPE = 0x40
-} uv_stdio_flags;
-
-typedef struct uv_stdio_container_s {
-  uv_stdio_flags flags;
-
-  union {
-    uv_stream_t* stream;
-    int fd;
-  } data;
-} uv_stdio_container_t;
-
-typedef struct uv_process_options_s {
-  uv_exit_cb exit_cb; /* Called after the process exits. */
-  const char* file;   /* Path to program to execute. */
-  /*
-   * Command line arguments. args[0] should be the path to the program. On
-   * Windows this uses CreateProcess which concatenates the arguments into a
-   * string this can cause some strange errors. See the note at
-   * windows_verbatim_arguments.
-   */
-  char** args;
-  /*
-   * This will be set as the environ variable in the subprocess. If this is
-   * NULL then the parents environ will be used.
-   */
-  char** env;
-  /*
-   * If non-null this represents a directory the subprocess should execute
-   * in. Stands for current working directory.
-   */
-  const char* cwd;
-  /*
-   * Various flags that control how uv_spawn() behaves. See the definition of
-   * `enum uv_process_flags` below.
-   */
-  unsigned int flags;
-  /*
-   * The `stdio` field points to an array of uv_stdio_container_t structs that
-   * describe the file descriptors that will be made available to the child
-   * process. The convention is that stdio[0] points to stdin, fd 1 is used for
-   * stdout, and fd 2 is stderr.
-   *
-   * Note that on windows file descriptors greater than 2 are available to the
-   * child process only if the child processes uses the MSVCRT runtime.
-   */
-  int stdio_count;
-  uv_stdio_container_t* stdio;
-  /*
-   * Libuv can change the child process' user/group id. This happens only when
-   * the appropriate bits are set in the flags fields. This is not supported on
-   * windows; uv_spawn() will fail and set the error to UV_ENOTSUP.
-   */
-  uv_uid_t uid;
-  uv_gid_t gid;
-} uv_process_options_t;
-
-/*
- * These are the flags that can be used for the uv_process_options.flags field.
- */
-enum uv_process_flags {
-  /*
-   * Set the child process' user id. The user id is supplied in the `uid` field
-   * of the options struct. This does not work on windows; setting this flag
-   * will cause uv_spawn() to fail.
-   */
-  UV_PROCESS_SETUID = (1 << 0),
-  /*
-   * Set the child process' group id. The user id is supplied in the `gid`
-   * field of the options struct. This does not work on windows; setting this
-   * flag will cause uv_spawn() to fail.
-   */
-  UV_PROCESS_SETGID = (1 << 1),
-  /*
-   * Do not wrap any arguments in quotes, or perform any other escaping, when
-   * converting the argument list into a command line string. This option is
-   * only meaningful on Windows systems. On Unix it is silently ignored.
-   */
-  UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2),
-  /*
-   * Spawn the child process in a detached state - this will make it a process
-   * group leader, and will effectively enable the child to keep running after
-   * the parent exits.  Note that the child process will still keep the
-   * parent's event loop alive unless the parent process calls uv_unref() on
-   * the child's process handle.
-   */
-  UV_PROCESS_DETACHED = (1 << 3),
-  /*
-   * Hide the subprocess window that would normally be created. This option is
-   * only meaningful on Windows systems. On Unix it is silently ignored.
-   */
-  UV_PROCESS_WINDOWS_HIDE = (1 << 4),
-  /*
-   * Hide the subprocess console window that would normally be created. This
-   * option is only meaningful on Windows systems. On Unix it is silently
-   * ignored.
-   */
-  UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5),
-  /*
-   * Hide the subprocess GUI window that would normally be created. This
-   * option is only meaningful on Windows systems. On Unix it is silently
-   * ignored.
-   */
-  UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6)
-};
-
-/*
- * uv_process_t is a subclass of uv_handle_t.
- */
-struct uv_process_s {
-  UV_HANDLE_FIELDS
-  uv_exit_cb exit_cb;
-  int pid;
-  UV_PROCESS_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_spawn(uv_loop_t* loop,
-                       uv_process_t* handle,
-                       const uv_process_options_t* options);
-UV_EXTERN int uv_process_kill(uv_process_t*, int signum);
-UV_EXTERN int uv_kill(int pid, int signum);
-UV_EXTERN uv_pid_t uv_process_get_pid(const uv_process_t*);
-
-
-/*
- * uv_work_t is a subclass of uv_req_t.
- */
-struct uv_work_s {
-  UV_REQ_FIELDS
-  uv_loop_t* loop;
-  uv_work_cb work_cb;
-  uv_after_work_cb after_work_cb;
-  UV_WORK_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_queue_work(uv_loop_t* loop,
-                            uv_work_t* req,
-                            uv_work_cb work_cb,
-                            uv_after_work_cb after_work_cb);
-
-UV_EXTERN int uv_cancel(uv_req_t* req);
-
-
-struct uv_cpu_times_s {
-  uint64_t user;
-  uint64_t nice;
-  uint64_t sys;
-  uint64_t idle;
-  uint64_t irq;
-};
-
-struct uv_cpu_info_s {
-  char* model;
-  int speed;
-  struct uv_cpu_times_s cpu_times;
-};
-
-struct uv_interface_address_s {
-  char* name;
-  char phys_addr[6];
-  int is_internal;
-  union {
-    struct sockaddr_in address4;
-    struct sockaddr_in6 address6;
-  } address;
-  union {
-    struct sockaddr_in netmask4;
-    struct sockaddr_in6 netmask6;
-  } netmask;
-};
-
-struct uv_passwd_s {
-  char* username;
-  long uid;
-  long gid;
-  char* shell;
-  char* homedir;
-};
-
-struct uv_utsname_s {
-  char sysname[256];
-  char release[256];
-  char version[256];
-  char machine[256];
-  /* This struct does not contain the nodename and domainname fields present in
-     the utsname type. domainname is a GNU extension. Both fields are referred
-     to as meaningless in the docs. */
-};
-
-typedef enum {
-  UV_DIRENT_UNKNOWN,
-  UV_DIRENT_FILE,
-  UV_DIRENT_DIR,
-  UV_DIRENT_LINK,
-  UV_DIRENT_FIFO,
-  UV_DIRENT_SOCKET,
-  UV_DIRENT_CHAR,
-  UV_DIRENT_BLOCK
-} uv_dirent_type_t;
-
-struct uv_dirent_s {
-  const char* name;
-  uv_dirent_type_t type;
-};
-
-UV_EXTERN char** uv_setup_args(int argc, char** argv);
-UV_EXTERN int uv_get_process_title(char* buffer, size_t size);
-UV_EXTERN int uv_set_process_title(const char* title);
-UV_EXTERN int uv_resident_set_memory(size_t* rss);
-UV_EXTERN int uv_uptime(double* uptime);
-UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd);
-UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd);
-
-typedef struct {
-  long tv_sec;
-  long tv_usec;
-} uv_timeval_t;
-
-typedef struct {
-  int64_t tv_sec;
-  int32_t tv_usec;
-} uv_timeval64_t;
-
-typedef struct {
-   uv_timeval_t ru_utime; /* user CPU time used */
-   uv_timeval_t ru_stime; /* system CPU time used */
-   uint64_t ru_maxrss;    /* maximum resident set size */
-   uint64_t ru_ixrss;     /* integral shared memory size */
-   uint64_t ru_idrss;     /* integral unshared data size */
-   uint64_t ru_isrss;     /* integral unshared stack size */
-   uint64_t ru_minflt;    /* page reclaims (soft page faults) */
-   uint64_t ru_majflt;    /* page faults (hard page faults) */
-   uint64_t ru_nswap;     /* swaps */
-   uint64_t ru_inblock;   /* block input operations */
-   uint64_t ru_oublock;   /* block output operations */
-   uint64_t ru_msgsnd;    /* IPC messages sent */
-   uint64_t ru_msgrcv;    /* IPC messages received */
-   uint64_t ru_nsignals;  /* signals received */
-   uint64_t ru_nvcsw;     /* voluntary context switches */
-   uint64_t ru_nivcsw;    /* involuntary context switches */
-} uv_rusage_t;
-
-UV_EXTERN int uv_getrusage(uv_rusage_t* rusage);
-
-UV_EXTERN int uv_os_homedir(char* buffer, size_t* size);
-UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size);
-UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd);
-UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd);
-UV_EXTERN uv_pid_t uv_os_getpid(void);
-UV_EXTERN uv_pid_t uv_os_getppid(void);
-
-#define UV_PRIORITY_LOW 19
-#define UV_PRIORITY_BELOW_NORMAL 10
-#define UV_PRIORITY_NORMAL 0
-#define UV_PRIORITY_ABOVE_NORMAL -7
-#define UV_PRIORITY_HIGH -14
-#define UV_PRIORITY_HIGHEST -20
-
-UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int* priority);
-UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority);
-
-UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count);
-UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count);
-
-UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses,
-                                     int* count);
-UV_EXTERN void uv_free_interface_addresses(uv_interface_address_t* addresses,
-                                           int count);
-
-UV_EXTERN int uv_os_getenv(const char* name, char* buffer, size_t* size);
-UV_EXTERN int uv_os_setenv(const char* name, const char* value);
-UV_EXTERN int uv_os_unsetenv(const char* name);
-
-#ifdef MAXHOSTNAMELEN
-# define UV_MAXHOSTNAMESIZE (MAXHOSTNAMELEN + 1)
-#else
-  /*
-    Fallback for the maximum hostname size, including the null terminator. The
-    Windows gethostname() documentation states that 256 bytes will always be
-    large enough to hold the null-terminated hostname.
-  */
-# define UV_MAXHOSTNAMESIZE 256
-#endif
-
-UV_EXTERN int uv_os_gethostname(char* buffer, size_t* size);
-
-UV_EXTERN int uv_os_uname(uv_utsname_t* buffer);
-
-
-typedef enum {
-  UV_FS_UNKNOWN = -1,
-  UV_FS_CUSTOM,
-  UV_FS_OPEN,
-  UV_FS_CLOSE,
-  UV_FS_READ,
-  UV_FS_WRITE,
-  UV_FS_SENDFILE,
-  UV_FS_STAT,
-  UV_FS_LSTAT,
-  UV_FS_FSTAT,
-  UV_FS_FTRUNCATE,
-  UV_FS_UTIME,
-  UV_FS_FUTIME,
-  UV_FS_ACCESS,
-  UV_FS_CHMOD,
-  UV_FS_FCHMOD,
-  UV_FS_FSYNC,
-  UV_FS_FDATASYNC,
-  UV_FS_UNLINK,
-  UV_FS_RMDIR,
-  UV_FS_MKDIR,
-  UV_FS_MKDTEMP,
-  UV_FS_RENAME,
-  UV_FS_SCANDIR,
-  UV_FS_LINK,
-  UV_FS_SYMLINK,
-  UV_FS_READLINK,
-  UV_FS_CHOWN,
-  UV_FS_FCHOWN,
-  UV_FS_REALPATH,
-  UV_FS_COPYFILE,
-  UV_FS_LCHOWN,
-  UV_FS_OPENDIR,
-  UV_FS_READDIR,
-  UV_FS_CLOSEDIR
-} uv_fs_type;
-
-struct uv_dir_s {
-  uv_dirent_t* dirents;
-  size_t nentries;
-  void* reserved[4];
-  UV_DIR_PRIVATE_FIELDS
-};
-
-/* uv_fs_t is a subclass of uv_req_t. */
-struct uv_fs_s {
-  UV_REQ_FIELDS
-  uv_fs_type fs_type;
-  uv_loop_t* loop;
-  uv_fs_cb cb;
-  ssize_t result;
-  void* ptr;
-  const char* path;
-  uv_stat_t statbuf;  /* Stores the result of uv_fs_stat() and uv_fs_fstat(). */
-  UV_FS_PRIVATE_FIELDS
-};
-
-UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*);
-UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*);
-UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*);
-UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*);
-UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*);
-
-UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req);
-UV_EXTERN int uv_fs_close(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          uv_file file,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_open(uv_loop_t* loop,
-                         uv_fs_t* req,
-                         const char* path,
-                         int flags,
-                         int mode,
-                         uv_fs_cb cb);
-UV_EXTERN int uv_fs_read(uv_loop_t* loop,
-                         uv_fs_t* req,
-                         uv_file file,
-                         const uv_buf_t bufs[],
-                         unsigned int nbufs,
-                         int64_t offset,
-                         uv_fs_cb cb);
-UV_EXTERN int uv_fs_unlink(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           const char* path,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_write(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          uv_file file,
-                          const uv_buf_t bufs[],
-                          unsigned int nbufs,
-                          int64_t offset,
-                          uv_fs_cb cb);
-/*
- * This flag can be used with uv_fs_copyfile() to return an error if the
- * destination already exists.
- */
-#define UV_FS_COPYFILE_EXCL   0x0001
-
-/*
- * This flag can be used with uv_fs_copyfile() to attempt to create a reflink.
- * If copy-on-write is not supported, a fallback copy mechanism is used.
- */
-#define UV_FS_COPYFILE_FICLONE 0x0002
-
-/*
- * This flag can be used with uv_fs_copyfile() to attempt to create a reflink.
- * If copy-on-write is not supported, an error is returned.
- */
-#define UV_FS_COPYFILE_FICLONE_FORCE 0x0004
-
-UV_EXTERN int uv_fs_copyfile(uv_loop_t* loop,
-                             uv_fs_t* req,
-                             const char* path,
-                             const char* new_path,
-                             int flags,
-                             uv_fs_cb cb);
-UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          int mode,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop,
-                            uv_fs_t* req,
-                            const char* tpl,
-                            uv_fs_cb cb);
-UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_scandir(uv_loop_t* loop,
-                            uv_fs_t* req,
-                            const char* path,
-                            int flags,
-                            uv_fs_cb cb);
-UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req,
-                                 uv_dirent_t* ent);
-UV_EXTERN int uv_fs_opendir(uv_loop_t* loop,
-                            uv_fs_t* req,
-                            const char* path,
-                            uv_fs_cb cb);
-UV_EXTERN int uv_fs_readdir(uv_loop_t* loop,
-                            uv_fs_t* req,
-                            uv_dir_t* dir,
-                            uv_fs_cb cb);
-UV_EXTERN int uv_fs_closedir(uv_loop_t* loop,
-                             uv_fs_t* req,
-                             uv_dir_t* dir,
-                             uv_fs_cb cb);
-UV_EXTERN int uv_fs_stat(uv_loop_t* loop,
-                         uv_fs_t* req,
-                         const char* path,
-                         uv_fs_cb cb);
-UV_EXTERN int uv_fs_fstat(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          uv_file file,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_rename(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           const char* path,
-                           const char* new_path,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_fsync(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          uv_file file,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop,
-                              uv_fs_t* req,
-                              uv_file file,
-                              uv_fs_cb cb);
-UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop,
-                              uv_fs_t* req,
-                              uv_file file,
-                              int64_t offset,
-                              uv_fs_cb cb);
-UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop,
-                             uv_fs_t* req,
-                             uv_file out_fd,
-                             uv_file in_fd,
-                             int64_t in_offset,
-                             size_t length,
-                             uv_fs_cb cb);
-UV_EXTERN int uv_fs_access(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           const char* path,
-                           int mode,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_chmod(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          int mode,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_utime(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          double atime,
-                          double mtime,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_futime(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           uv_file file,
-                           double atime,
-                           double mtime,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_lstat(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_link(uv_loop_t* loop,
-                         uv_fs_t* req,
-                         const char* path,
-                         const char* new_path,
-                         uv_fs_cb cb);
-
-/*
- * This flag can be used with uv_fs_symlink() on Windows to specify whether
- * path argument points to a directory.
- */
-#define UV_FS_SYMLINK_DIR          0x0001
-
-/*
- * This flag can be used with uv_fs_symlink() on Windows to specify whether
- * the symlink is to be created using junction points.
- */
-#define UV_FS_SYMLINK_JUNCTION     0x0002
-
-UV_EXTERN int uv_fs_symlink(uv_loop_t* loop,
-                            uv_fs_t* req,
-                            const char* path,
-                            const char* new_path,
-                            int flags,
-                            uv_fs_cb cb);
-UV_EXTERN int uv_fs_readlink(uv_loop_t* loop,
-                             uv_fs_t* req,
-                             const char* path,
-                             uv_fs_cb cb);
-UV_EXTERN int uv_fs_realpath(uv_loop_t* loop,
-                             uv_fs_t* req,
-                             const char* path,
-                             uv_fs_cb cb);
-UV_EXTERN int uv_fs_fchmod(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           uv_file file,
-                           int mode,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_chown(uv_loop_t* loop,
-                          uv_fs_t* req,
-                          const char* path,
-                          uv_uid_t uid,
-                          uv_gid_t gid,
-                          uv_fs_cb cb);
-UV_EXTERN int uv_fs_fchown(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           uv_file file,
-                           uv_uid_t uid,
-                           uv_gid_t gid,
-                           uv_fs_cb cb);
-UV_EXTERN int uv_fs_lchown(uv_loop_t* loop,
-                           uv_fs_t* req,
-                           const char* path,
-                           uv_uid_t uid,
-                           uv_gid_t gid,
-                           uv_fs_cb cb);
-
-
-enum uv_fs_event {
-  UV_RENAME = 1,
-  UV_CHANGE = 2
-};
-
-
-struct uv_fs_event_s {
-  UV_HANDLE_FIELDS
-  /* private */
-  char* path;
-  UV_FS_EVENT_PRIVATE_FIELDS
-};
-
-
-/*
- * uv_fs_stat() based polling file watcher.
- */
-struct uv_fs_poll_s {
-  UV_HANDLE_FIELDS
-  /* Private, don't touch. */
-  void* poll_ctx;
-};
-
-UV_EXTERN int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle);
-UV_EXTERN int uv_fs_poll_start(uv_fs_poll_t* handle,
-                               uv_fs_poll_cb poll_cb,
-                               const char* path,
-                               unsigned int interval);
-UV_EXTERN int uv_fs_poll_stop(uv_fs_poll_t* handle);
-UV_EXTERN int uv_fs_poll_getpath(uv_fs_poll_t* handle,
-                                 char* buffer,
-                                 size_t* size);
-
-
-struct uv_signal_s {
-  UV_HANDLE_FIELDS
-  uv_signal_cb signal_cb;
-  int signum;
-  UV_SIGNAL_PRIVATE_FIELDS
-};
-
-UV_EXTERN int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle);
-UV_EXTERN int uv_signal_start(uv_signal_t* handle,
-                              uv_signal_cb signal_cb,
-                              int signum);
-UV_EXTERN int uv_signal_start_oneshot(uv_signal_t* handle,
-                                      uv_signal_cb signal_cb,
-                                      int signum);
-UV_EXTERN int uv_signal_stop(uv_signal_t* handle);
-
-UV_EXTERN void uv_loadavg(double avg[3]);
-
-
-/*
- * Flags to be passed to uv_fs_event_start().
- */
-enum uv_fs_event_flags {
-  /*
-   * By default, if the fs event watcher is given a directory name, we will
-   * watch for all events in that directory. This flags overrides this behavior
-   * and makes fs_event report only changes to the directory entry itself. This
-   * flag does not affect individual files watched.
-   * This flag is currently not implemented yet on any backend.
-   */
-  UV_FS_EVENT_WATCH_ENTRY = 1,
-
-  /*
-   * By default uv_fs_event will try to use a kernel interface such as inotify
-   * or kqueue to detect events. This may not work on remote filesystems such
-   * as NFS mounts. This flag makes fs_event fall back to calling stat() on a
-   * regular interval.
-   * This flag is currently not implemented yet on any backend.
-   */
-  UV_FS_EVENT_STAT = 2,
-
-  /*
-   * By default, event watcher, when watching directory, is not registering
-   * (is ignoring) changes in it's subdirectories.
-   * This flag will override this behaviour on platforms that support it.
-   */
-  UV_FS_EVENT_RECURSIVE = 4
-};
-
-
-UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle);
-UV_EXTERN int uv_fs_event_start(uv_fs_event_t* handle,
-                                uv_fs_event_cb cb,
-                                const char* path,
-                                unsigned int flags);
-UV_EXTERN int uv_fs_event_stop(uv_fs_event_t* handle);
-UV_EXTERN int uv_fs_event_getpath(uv_fs_event_t* handle,
-                                  char* buffer,
-                                  size_t* size);
-
-UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr);
-UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr);
-
-UV_EXTERN int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size);
-UV_EXTERN int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size);
-
-UV_EXTERN int uv_inet_ntop(int af, const void* src, char* dst, size_t size);
-UV_EXTERN int uv_inet_pton(int af, const char* src, void* dst);
-
-#if defined(IF_NAMESIZE)
-# define UV_IF_NAMESIZE (IF_NAMESIZE + 1)
-#elif defined(IFNAMSIZ)
-# define UV_IF_NAMESIZE (IFNAMSIZ + 1)
-#else
-# define UV_IF_NAMESIZE (16 + 1)
-#endif
-
-UV_EXTERN int uv_if_indextoname(unsigned int ifindex,
-                                char* buffer,
-                                size_t* size);
-UV_EXTERN int uv_if_indextoiid(unsigned int ifindex,
-                               char* buffer,
-                               size_t* size);
-
-UV_EXTERN int uv_exepath(char* buffer, size_t* size);
-
-UV_EXTERN int uv_cwd(char* buffer, size_t* size);
-
-UV_EXTERN int uv_chdir(const char* dir);
-
-UV_EXTERN uint64_t uv_get_free_memory(void);
-UV_EXTERN uint64_t uv_get_total_memory(void);
-UV_EXTERN uint64_t uv_get_constrained_memory(void);
-
-UV_EXTERN uint64_t uv_hrtime(void);
-
-UV_EXTERN void uv_disable_stdio_inheritance(void);
-
-UV_EXTERN int uv_dlopen(const char* filename, uv_lib_t* lib);
-UV_EXTERN void uv_dlclose(uv_lib_t* lib);
-UV_EXTERN int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr);
-UV_EXTERN const char* uv_dlerror(const uv_lib_t* lib);
-
-UV_EXTERN int uv_mutex_init(uv_mutex_t* handle);
-UV_EXTERN int uv_mutex_init_recursive(uv_mutex_t* handle);
-UV_EXTERN void uv_mutex_destroy(uv_mutex_t* handle);
-UV_EXTERN void uv_mutex_lock(uv_mutex_t* handle);
-UV_EXTERN int uv_mutex_trylock(uv_mutex_t* handle);
-UV_EXTERN void uv_mutex_unlock(uv_mutex_t* handle);
-
-UV_EXTERN int uv_rwlock_init(uv_rwlock_t* rwlock);
-UV_EXTERN void uv_rwlock_destroy(uv_rwlock_t* rwlock);
-UV_EXTERN void uv_rwlock_rdlock(uv_rwlock_t* rwlock);
-UV_EXTERN int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock);
-UV_EXTERN void uv_rwlock_rdunlock(uv_rwlock_t* rwlock);
-UV_EXTERN void uv_rwlock_wrlock(uv_rwlock_t* rwlock);
-UV_EXTERN int uv_rwlock_trywrlock(uv_rwlock_t* rwlock);
-UV_EXTERN void uv_rwlock_wrunlock(uv_rwlock_t* rwlock);
-
-UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value);
-UV_EXTERN void uv_sem_destroy(uv_sem_t* sem);
-UV_EXTERN void uv_sem_post(uv_sem_t* sem);
-UV_EXTERN void uv_sem_wait(uv_sem_t* sem);
-UV_EXTERN int uv_sem_trywait(uv_sem_t* sem);
-
-UV_EXTERN int uv_cond_init(uv_cond_t* cond);
-UV_EXTERN void uv_cond_destroy(uv_cond_t* cond);
-UV_EXTERN void uv_cond_signal(uv_cond_t* cond);
-UV_EXTERN void uv_cond_broadcast(uv_cond_t* cond);
-
-UV_EXTERN int uv_barrier_init(uv_barrier_t* barrier, unsigned int count);
-UV_EXTERN void uv_barrier_destroy(uv_barrier_t* barrier);
-UV_EXTERN int uv_barrier_wait(uv_barrier_t* barrier);
-
-UV_EXTERN void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex);
-UV_EXTERN int uv_cond_timedwait(uv_cond_t* cond,
-                                uv_mutex_t* mutex,
-                                uint64_t timeout);
-
-UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void));
-
-UV_EXTERN int uv_key_create(uv_key_t* key);
-UV_EXTERN void uv_key_delete(uv_key_t* key);
-UV_EXTERN void* uv_key_get(uv_key_t* key);
-UV_EXTERN void uv_key_set(uv_key_t* key, void* value);
-
-UV_EXTERN int uv_gettimeofday(uv_timeval64_t* tv);
-
-typedef void (*uv_thread_cb)(void* arg);
-
-UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg);
-
-typedef enum {
-  UV_THREAD_NO_FLAGS = 0x00,
-  UV_THREAD_HAS_STACK_SIZE = 0x01
-} uv_thread_create_flags;
-
-struct uv_thread_options_s {
-  unsigned int flags;
-  size_t stack_size;
-  /* More fields may be added at any time. */
-};
-
-typedef struct uv_thread_options_s uv_thread_options_t;
-
-UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid,
-                                  const uv_thread_options_t* params,
-                                  uv_thread_cb entry,
-                                  void* arg);
-UV_EXTERN uv_thread_t uv_thread_self(void);
-UV_EXTERN int uv_thread_join(uv_thread_t *tid);
-UV_EXTERN int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2);
-
-/* The presence of these unions force similar struct layout. */
-#define XX(_, name) uv_ ## name ## _t name;
-union uv_any_handle {
-  UV_HANDLE_TYPE_MAP(XX)
-};
-
-union uv_any_req {
-  UV_REQ_TYPE_MAP(XX)
-};
-#undef XX
-
-
-struct uv_loop_s {
-  /* User data - use this for whatever. */
-  void* data;
-  /* Loop reference counting. */
-  unsigned int active_handles;
-  void* handle_queue[2];
-  union {
-    void* unused[2];
-    unsigned int count;
-  } active_reqs;
-  /* Internal flag to signal loop stop. */
-  unsigned int stop_flag;
-  UV_LOOP_PRIVATE_FIELDS
-};
-
-UV_EXTERN void* uv_loop_get_data(const uv_loop_t*);
-UV_EXTERN void uv_loop_set_data(uv_loop_t*, void* data);
-
-/* Don't export the private CPP symbols. */
-#undef UV_HANDLE_TYPE_PRIVATE
-#undef UV_REQ_TYPE_PRIVATE
-#undef UV_REQ_PRIVATE_FIELDS
-#undef UV_STREAM_PRIVATE_FIELDS
-#undef UV_TCP_PRIVATE_FIELDS
-#undef UV_PREPARE_PRIVATE_FIELDS
-#undef UV_CHECK_PRIVATE_FIELDS
-#undef UV_IDLE_PRIVATE_FIELDS
-#undef UV_ASYNC_PRIVATE_FIELDS
-#undef UV_TIMER_PRIVATE_FIELDS
-#undef UV_GETADDRINFO_PRIVATE_FIELDS
-#undef UV_GETNAMEINFO_PRIVATE_FIELDS
-#undef UV_FS_REQ_PRIVATE_FIELDS
-#undef UV_WORK_PRIVATE_FIELDS
-#undef UV_FS_EVENT_PRIVATE_FIELDS
-#undef UV_SIGNAL_PRIVATE_FIELDS
-#undef UV_LOOP_PRIVATE_FIELDS
-#undef UV_LOOP_PRIVATE_PLATFORM_FIELDS
-#undef UV__ERR
-
-#endif /* UV_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/android-ifaddrs.h b/wpiutil/src/main/native/libuv/include/uv/android-ifaddrs.h
deleted file mode 100644
index 9cd19fe..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/android-ifaddrs.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 1995, 1999
- *	Berkeley Software Design, 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:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``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 Berkeley Software Design, Inc. 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.
- *
- *	BSDI ifaddrs.h,v 2.5 2000/02/23 14:51:59 dab Exp
- */
-
-#ifndef	_IFADDRS_H_
-#define	_IFADDRS_H_
-
-struct ifaddrs {
-	struct ifaddrs  *ifa_next;
-	char		*ifa_name;
-	unsigned int	 ifa_flags;
-	struct sockaddr	*ifa_addr;
-	struct sockaddr	*ifa_netmask;
-	struct sockaddr	*ifa_dstaddr;
-	void		*ifa_data;
-};
-
-/*
- * This may have been defined in <net/if.h>.  Note that if <net/if.h> is
- * to be included it must be included before this header file.
- */
-#ifndef	ifa_broadaddr
-#define	ifa_broadaddr	ifa_dstaddr	/* broadcast address interface */
-#endif
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-extern int getifaddrs(struct ifaddrs **ifap);
-extern void freeifaddrs(struct ifaddrs *ifa);
-__END_DECLS
-
-#endif
diff --git a/wpiutil/src/main/native/libuv/include/uv/bsd.h b/wpiutil/src/main/native/libuv/include/uv/bsd.h
deleted file mode 100644
index 2d72b3d..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/bsd.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_BSD_H
-#define UV_BSD_H
-
-#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
-  uv__io_t event_watcher;                                                     \
-
-#define UV_IO_PRIVATE_PLATFORM_FIELDS                                         \
-  int rcount;                                                                 \
-  int wcount;                                                                 \
-
-#define UV_HAVE_KQUEUE 1
-
-#endif /* UV_BSD_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/darwin.h b/wpiutil/src/main/native/libuv/include/uv/darwin.h
deleted file mode 100644
index d226415..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/darwin.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_DARWIN_H
-#define UV_DARWIN_H
-
-#if defined(__APPLE__) && defined(__MACH__)
-# include <mach/mach.h>
-# include <mach/task.h>
-# include <mach/semaphore.h>
-# include <TargetConditionals.h>
-# define UV_PLATFORM_SEM_T semaphore_t
-#endif
-
-#define UV_IO_PRIVATE_PLATFORM_FIELDS                                         \
-  int rcount;                                                                 \
-  int wcount;                                                                 \
-
-#define UV_PLATFORM_LOOP_FIELDS                                               \
-  uv_thread_t cf_thread;                                                      \
-  void* _cf_reserved;                                                         \
-  void* cf_state;                                                             \
-  uv_mutex_t cf_mutex;                                                        \
-  uv_sem_t cf_sem;                                                            \
-  void* cf_signals[2];                                                        \
-
-#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
-  uv__io_t event_watcher;                                                     \
-  char* realpath;                                                             \
-  int realpath_len;                                                           \
-  int cf_flags;                                                               \
-  uv_async_t* cf_cb;                                                          \
-  void* cf_events[2];                                                         \
-  void* cf_member[2];                                                         \
-  int cf_error;                                                               \
-  uv_mutex_t cf_mutex;                                                        \
-
-#define UV_STREAM_PRIVATE_PLATFORM_FIELDS                                     \
-  void* select;                                                               \
-
-#define UV_HAVE_KQUEUE 1
-
-#endif /* UV_DARWIN_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/errno.h b/wpiutil/src/main/native/libuv/include/uv/errno.h
deleted file mode 100644
index 8eeb95d..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/errno.h
+++ /dev/null
@@ -1,443 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_ERRNO_H_
-#define UV_ERRNO_H_
-
-#include <errno.h>
-#if EDOM > 0
-# define UV__ERR(x) (-(x))
-#else
-# define UV__ERR(x) (x)
-#endif
-
-#define UV__EOF     (-4095)
-#define UV__UNKNOWN (-4094)
-
-#define UV__EAI_ADDRFAMILY  (-3000)
-#define UV__EAI_AGAIN       (-3001)
-#define UV__EAI_BADFLAGS    (-3002)
-#define UV__EAI_CANCELED    (-3003)
-#define UV__EAI_FAIL        (-3004)
-#define UV__EAI_FAMILY      (-3005)
-#define UV__EAI_MEMORY      (-3006)
-#define UV__EAI_NODATA      (-3007)
-#define UV__EAI_NONAME      (-3008)
-#define UV__EAI_OVERFLOW    (-3009)
-#define UV__EAI_SERVICE     (-3010)
-#define UV__EAI_SOCKTYPE    (-3011)
-#define UV__EAI_BADHINTS    (-3013)
-#define UV__EAI_PROTOCOL    (-3014)
-
-/* Only map to the system errno on non-Windows platforms. It's apparently
- * a fairly common practice for Windows programmers to redefine errno codes.
- */
-#if defined(E2BIG) && !defined(_WIN32)
-# define UV__E2BIG UV__ERR(E2BIG)
-#else
-# define UV__E2BIG (-4093)
-#endif
-
-#if defined(EACCES) && !defined(_WIN32)
-# define UV__EACCES UV__ERR(EACCES)
-#else
-# define UV__EACCES (-4092)
-#endif
-
-#if defined(EADDRINUSE) && !defined(_WIN32)
-# define UV__EADDRINUSE UV__ERR(EADDRINUSE)
-#else
-# define UV__EADDRINUSE (-4091)
-#endif
-
-#if defined(EADDRNOTAVAIL) && !defined(_WIN32)
-# define UV__EADDRNOTAVAIL UV__ERR(EADDRNOTAVAIL)
-#else
-# define UV__EADDRNOTAVAIL (-4090)
-#endif
-
-#if defined(EAFNOSUPPORT) && !defined(_WIN32)
-# define UV__EAFNOSUPPORT UV__ERR(EAFNOSUPPORT)
-#else
-# define UV__EAFNOSUPPORT (-4089)
-#endif
-
-#if defined(EAGAIN) && !defined(_WIN32)
-# define UV__EAGAIN UV__ERR(EAGAIN)
-#else
-# define UV__EAGAIN (-4088)
-#endif
-
-#if defined(EALREADY) && !defined(_WIN32)
-# define UV__EALREADY UV__ERR(EALREADY)
-#else
-# define UV__EALREADY (-4084)
-#endif
-
-#if defined(EBADF) && !defined(_WIN32)
-# define UV__EBADF UV__ERR(EBADF)
-#else
-# define UV__EBADF (-4083)
-#endif
-
-#if defined(EBUSY) && !defined(_WIN32)
-# define UV__EBUSY UV__ERR(EBUSY)
-#else
-# define UV__EBUSY (-4082)
-#endif
-
-#if defined(ECANCELED) && !defined(_WIN32)
-# define UV__ECANCELED UV__ERR(ECANCELED)
-#else
-# define UV__ECANCELED (-4081)
-#endif
-
-#if defined(ECHARSET) && !defined(_WIN32)
-# define UV__ECHARSET UV__ERR(ECHARSET)
-#else
-# define UV__ECHARSET (-4080)
-#endif
-
-#if defined(ECONNABORTED) && !defined(_WIN32)
-# define UV__ECONNABORTED UV__ERR(ECONNABORTED)
-#else
-# define UV__ECONNABORTED (-4079)
-#endif
-
-#if defined(ECONNREFUSED) && !defined(_WIN32)
-# define UV__ECONNREFUSED UV__ERR(ECONNREFUSED)
-#else
-# define UV__ECONNREFUSED (-4078)
-#endif
-
-#if defined(ECONNRESET) && !defined(_WIN32)
-# define UV__ECONNRESET UV__ERR(ECONNRESET)
-#else
-# define UV__ECONNRESET (-4077)
-#endif
-
-#if defined(EDESTADDRREQ) && !defined(_WIN32)
-# define UV__EDESTADDRREQ UV__ERR(EDESTADDRREQ)
-#else
-# define UV__EDESTADDRREQ (-4076)
-#endif
-
-#if defined(EEXIST) && !defined(_WIN32)
-# define UV__EEXIST UV__ERR(EEXIST)
-#else
-# define UV__EEXIST (-4075)
-#endif
-
-#if defined(EFAULT) && !defined(_WIN32)
-# define UV__EFAULT UV__ERR(EFAULT)
-#else
-# define UV__EFAULT (-4074)
-#endif
-
-#if defined(EHOSTUNREACH) && !defined(_WIN32)
-# define UV__EHOSTUNREACH UV__ERR(EHOSTUNREACH)
-#else
-# define UV__EHOSTUNREACH (-4073)
-#endif
-
-#if defined(EINTR) && !defined(_WIN32)
-# define UV__EINTR UV__ERR(EINTR)
-#else
-# define UV__EINTR (-4072)
-#endif
-
-#if defined(EINVAL) && !defined(_WIN32)
-# define UV__EINVAL UV__ERR(EINVAL)
-#else
-# define UV__EINVAL (-4071)
-#endif
-
-#if defined(EIO) && !defined(_WIN32)
-# define UV__EIO UV__ERR(EIO)
-#else
-# define UV__EIO (-4070)
-#endif
-
-#if defined(EISCONN) && !defined(_WIN32)
-# define UV__EISCONN UV__ERR(EISCONN)
-#else
-# define UV__EISCONN (-4069)
-#endif
-
-#if defined(EISDIR) && !defined(_WIN32)
-# define UV__EISDIR UV__ERR(EISDIR)
-#else
-# define UV__EISDIR (-4068)
-#endif
-
-#if defined(ELOOP) && !defined(_WIN32)
-# define UV__ELOOP UV__ERR(ELOOP)
-#else
-# define UV__ELOOP (-4067)
-#endif
-
-#if defined(EMFILE) && !defined(_WIN32)
-# define UV__EMFILE UV__ERR(EMFILE)
-#else
-# define UV__EMFILE (-4066)
-#endif
-
-#if defined(EMSGSIZE) && !defined(_WIN32)
-# define UV__EMSGSIZE UV__ERR(EMSGSIZE)
-#else
-# define UV__EMSGSIZE (-4065)
-#endif
-
-#if defined(ENAMETOOLONG) && !defined(_WIN32)
-# define UV__ENAMETOOLONG UV__ERR(ENAMETOOLONG)
-#else
-# define UV__ENAMETOOLONG (-4064)
-#endif
-
-#if defined(ENETDOWN) && !defined(_WIN32)
-# define UV__ENETDOWN UV__ERR(ENETDOWN)
-#else
-# define UV__ENETDOWN (-4063)
-#endif
-
-#if defined(ENETUNREACH) && !defined(_WIN32)
-# define UV__ENETUNREACH UV__ERR(ENETUNREACH)
-#else
-# define UV__ENETUNREACH (-4062)
-#endif
-
-#if defined(ENFILE) && !defined(_WIN32)
-# define UV__ENFILE UV__ERR(ENFILE)
-#else
-# define UV__ENFILE (-4061)
-#endif
-
-#if defined(ENOBUFS) && !defined(_WIN32)
-# define UV__ENOBUFS UV__ERR(ENOBUFS)
-#else
-# define UV__ENOBUFS (-4060)
-#endif
-
-#if defined(ENODEV) && !defined(_WIN32)
-# define UV__ENODEV UV__ERR(ENODEV)
-#else
-# define UV__ENODEV (-4059)
-#endif
-
-#if defined(ENOENT) && !defined(_WIN32)
-# define UV__ENOENT UV__ERR(ENOENT)
-#else
-# define UV__ENOENT (-4058)
-#endif
-
-#if defined(ENOMEM) && !defined(_WIN32)
-# define UV__ENOMEM UV__ERR(ENOMEM)
-#else
-# define UV__ENOMEM (-4057)
-#endif
-
-#if defined(ENONET) && !defined(_WIN32)
-# define UV__ENONET UV__ERR(ENONET)
-#else
-# define UV__ENONET (-4056)
-#endif
-
-#if defined(ENOSPC) && !defined(_WIN32)
-# define UV__ENOSPC UV__ERR(ENOSPC)
-#else
-# define UV__ENOSPC (-4055)
-#endif
-
-#if defined(ENOSYS) && !defined(_WIN32)
-# define UV__ENOSYS UV__ERR(ENOSYS)
-#else
-# define UV__ENOSYS (-4054)
-#endif
-
-#if defined(ENOTCONN) && !defined(_WIN32)
-# define UV__ENOTCONN UV__ERR(ENOTCONN)
-#else
-# define UV__ENOTCONN (-4053)
-#endif
-
-#if defined(ENOTDIR) && !defined(_WIN32)
-# define UV__ENOTDIR UV__ERR(ENOTDIR)
-#else
-# define UV__ENOTDIR (-4052)
-#endif
-
-#if defined(ENOTEMPTY) && !defined(_WIN32)
-# define UV__ENOTEMPTY UV__ERR(ENOTEMPTY)
-#else
-# define UV__ENOTEMPTY (-4051)
-#endif
-
-#if defined(ENOTSOCK) && !defined(_WIN32)
-# define UV__ENOTSOCK UV__ERR(ENOTSOCK)
-#else
-# define UV__ENOTSOCK (-4050)
-#endif
-
-#if defined(ENOTSUP) && !defined(_WIN32)
-# define UV__ENOTSUP UV__ERR(ENOTSUP)
-#else
-# define UV__ENOTSUP (-4049)
-#endif
-
-#if defined(EPERM) && !defined(_WIN32)
-# define UV__EPERM UV__ERR(EPERM)
-#else
-# define UV__EPERM (-4048)
-#endif
-
-#if defined(EPIPE) && !defined(_WIN32)
-# define UV__EPIPE UV__ERR(EPIPE)
-#else
-# define UV__EPIPE (-4047)
-#endif
-
-#if defined(EPROTO) && !defined(_WIN32)
-# define UV__EPROTO UV__ERR(EPROTO)
-#else
-# define UV__EPROTO UV__ERR(4046)
-#endif
-
-#if defined(EPROTONOSUPPORT) && !defined(_WIN32)
-# define UV__EPROTONOSUPPORT UV__ERR(EPROTONOSUPPORT)
-#else
-# define UV__EPROTONOSUPPORT (-4045)
-#endif
-
-#if defined(EPROTOTYPE) && !defined(_WIN32)
-# define UV__EPROTOTYPE UV__ERR(EPROTOTYPE)
-#else
-# define UV__EPROTOTYPE (-4044)
-#endif
-
-#if defined(EROFS) && !defined(_WIN32)
-# define UV__EROFS UV__ERR(EROFS)
-#else
-# define UV__EROFS (-4043)
-#endif
-
-#if defined(ESHUTDOWN) && !defined(_WIN32)
-# define UV__ESHUTDOWN UV__ERR(ESHUTDOWN)
-#else
-# define UV__ESHUTDOWN (-4042)
-#endif
-
-#if defined(ESPIPE) && !defined(_WIN32)
-# define UV__ESPIPE UV__ERR(ESPIPE)
-#else
-# define UV__ESPIPE (-4041)
-#endif
-
-#if defined(ESRCH) && !defined(_WIN32)
-# define UV__ESRCH UV__ERR(ESRCH)
-#else
-# define UV__ESRCH (-4040)
-#endif
-
-#if defined(ETIMEDOUT) && !defined(_WIN32)
-# define UV__ETIMEDOUT UV__ERR(ETIMEDOUT)
-#else
-# define UV__ETIMEDOUT (-4039)
-#endif
-
-#if defined(ETXTBSY) && !defined(_WIN32)
-# define UV__ETXTBSY UV__ERR(ETXTBSY)
-#else
-# define UV__ETXTBSY (-4038)
-#endif
-
-#if defined(EXDEV) && !defined(_WIN32)
-# define UV__EXDEV UV__ERR(EXDEV)
-#else
-# define UV__EXDEV (-4037)
-#endif
-
-#if defined(EFBIG) && !defined(_WIN32)
-# define UV__EFBIG UV__ERR(EFBIG)
-#else
-# define UV__EFBIG (-4036)
-#endif
-
-#if defined(ENOPROTOOPT) && !defined(_WIN32)
-# define UV__ENOPROTOOPT UV__ERR(ENOPROTOOPT)
-#else
-# define UV__ENOPROTOOPT (-4035)
-#endif
-
-#if defined(ERANGE) && !defined(_WIN32)
-# define UV__ERANGE UV__ERR(ERANGE)
-#else
-# define UV__ERANGE (-4034)
-#endif
-
-#if defined(ENXIO) && !defined(_WIN32)
-# define UV__ENXIO UV__ERR(ENXIO)
-#else
-# define UV__ENXIO (-4033)
-#endif
-
-#if defined(EMLINK) && !defined(_WIN32)
-# define UV__EMLINK UV__ERR(EMLINK)
-#else
-# define UV__EMLINK (-4032)
-#endif
-
-/* EHOSTDOWN is not visible on BSD-like systems when _POSIX_C_SOURCE is
- * defined. Fortunately, its value is always 64 so it's possible albeit
- * icky to hard-code it.
- */
-#if defined(EHOSTDOWN) && !defined(_WIN32)
-# define UV__EHOSTDOWN UV__ERR(EHOSTDOWN)
-#elif defined(__APPLE__) || \
-      defined(__DragonFly__) || \
-      defined(__FreeBSD__) || \
-      defined(__FreeBSD_kernel__) || \
-      defined(__NetBSD__) || \
-      defined(__OpenBSD__)
-# define UV__EHOSTDOWN (-64)
-#else
-# define UV__EHOSTDOWN (-4031)
-#endif
-
-#if defined(EREMOTEIO) && !defined(_WIN32)
-# define UV__EREMOTEIO UV__ERR(EREMOTEIO)
-#else
-# define UV__EREMOTEIO (-4030)
-#endif
-
-#if defined(ENOTTY) && !defined(_WIN32)
-# define UV__ENOTTY UV__ERR(ENOTTY)
-#else
-# define UV__ENOTTY (-4029)
-#endif
-
-#if defined(EFTYPE) && !defined(_WIN32)
-# define UV__EFTYPE UV__ERR(EFTYPE)
-#else
-# define UV__EFTYPE (-4028)
-#endif
-
-
-#endif /* UV_ERRNO_H_ */
diff --git a/wpiutil/src/main/native/libuv/include/uv/linux.h b/wpiutil/src/main/native/libuv/include/uv/linux.h
deleted file mode 100644
index 9b38405..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/linux.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_LINUX_H
-#define UV_LINUX_H
-
-#define UV_PLATFORM_LOOP_FIELDS                                               \
-  uv__io_t inotify_read_watcher;                                              \
-  void* inotify_watchers;                                                     \
-  int inotify_fd;                                                             \
-
-#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
-  void* watchers[2];                                                          \
-  int wd;                                                                     \
-
-#endif /* UV_LINUX_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/posix.h b/wpiutil/src/main/native/libuv/include/uv/posix.h
deleted file mode 100644
index 9a96634..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/posix.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_POSIX_H
-#define UV_POSIX_H
-
-#define UV_PLATFORM_LOOP_FIELDS                                               \
-  struct pollfd* poll_fds;                                                    \
-  size_t poll_fds_used;                                                       \
-  size_t poll_fds_size;                                                       \
-  unsigned char poll_fds_iterating;                                           \
-
-#endif /* UV_POSIX_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/threadpool.h b/wpiutil/src/main/native/libuv/include/uv/threadpool.h
deleted file mode 100644
index 9708ebd..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/threadpool.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-/*
- * This file is private to libuv. It provides common functionality to both
- * Windows and Unix backends.
- */
-
-#ifndef UV_THREADPOOL_H_
-#define UV_THREADPOOL_H_
-
-struct uv__work {
-  void (*work)(struct uv__work *w);
-  void (*done)(struct uv__work *w, int status);
-  struct uv_loop_s* loop;
-  void* wq[2];
-};
-
-#endif /* UV_THREADPOOL_H_ */
diff --git a/wpiutil/src/main/native/libuv/include/uv/tree.h b/wpiutil/src/main/native/libuv/include/uv/tree.h
deleted file mode 100644
index f936416..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/tree.h
+++ /dev/null
@@ -1,768 +0,0 @@
-/*-
- * Copyright 2002 Niels Provos <provos@citi.umich.edu>
- * 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 AUTHOR ``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 AUTHOR 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  UV_TREE_H_
-#define  UV_TREE_H_
-
-#ifndef UV__UNUSED
-# if __GNUC__
-#  define UV__UNUSED __attribute__((unused))
-# else
-#  define UV__UNUSED
-# endif
-#endif
-
-/*
- * This file defines data structures for different types of trees:
- * splay trees and red-black trees.
- *
- * A splay tree is a self-organizing data structure.  Every operation
- * on the tree causes a splay to happen.  The splay moves the requested
- * node to the root of the tree and partly rebalances it.
- *
- * This has the benefit that request locality causes faster lookups as
- * the requested nodes move to the top of the tree.  On the other hand,
- * every lookup causes memory writes.
- *
- * The Balance Theorem bounds the total access time for m operations
- * and n inserts on an initially empty tree as O((m + n)lg n).  The
- * amortized cost for a sequence of m accesses to a splay tree is O(lg n);
- *
- * A red-black tree is a binary search tree with the node color as an
- * extra attribute.  It fulfills a set of conditions:
- *  - every search path from the root to a leaf consists of the
- *    same number of black nodes,
- *  - each red node (except for the root) has a black parent,
- *  - each leaf node is black.
- *
- * Every operation on a red-black tree is bounded as O(lg n).
- * The maximum height of a red-black tree is 2lg (n+1).
- */
-
-#define SPLAY_HEAD(name, type)                                                \
-struct name {                                                                 \
-  struct type *sph_root; /* root of the tree */                               \
-}
-
-#define SPLAY_INITIALIZER(root)                                               \
-  { NULL }
-
-#define SPLAY_INIT(root) do {                                                 \
-  (root)->sph_root = NULL;                                                    \
-} while (/*CONSTCOND*/ 0)
-
-#define SPLAY_ENTRY(type)                                                     \
-struct {                                                                      \
-  struct type *spe_left;          /* left element */                          \
-  struct type *spe_right;         /* right element */                         \
-}
-
-#define SPLAY_LEFT(elm, field)    (elm)->field.spe_left
-#define SPLAY_RIGHT(elm, field)   (elm)->field.spe_right
-#define SPLAY_ROOT(head)          (head)->sph_root
-#define SPLAY_EMPTY(head)         (SPLAY_ROOT(head) == NULL)
-
-/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
-#define SPLAY_ROTATE_RIGHT(head, tmp, field) do {                             \
-  SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field);              \
-  SPLAY_RIGHT(tmp, field) = (head)->sph_root;                                 \
-  (head)->sph_root = tmp;                                                     \
-} while (/*CONSTCOND*/ 0)
-
-#define SPLAY_ROTATE_LEFT(head, tmp, field) do {                              \
-  SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field);              \
-  SPLAY_LEFT(tmp, field) = (head)->sph_root;                                  \
-  (head)->sph_root = tmp;                                                     \
-} while (/*CONSTCOND*/ 0)
-
-#define SPLAY_LINKLEFT(head, tmp, field) do {                                 \
-  SPLAY_LEFT(tmp, field) = (head)->sph_root;                                  \
-  tmp = (head)->sph_root;                                                     \
-  (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);                     \
-} while (/*CONSTCOND*/ 0)
-
-#define SPLAY_LINKRIGHT(head, tmp, field) do {                                \
-  SPLAY_RIGHT(tmp, field) = (head)->sph_root;                                 \
-  tmp = (head)->sph_root;                                                     \
-  (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);                    \
-} while (/*CONSTCOND*/ 0)
-
-#define SPLAY_ASSEMBLE(head, node, left, right, field) do {                   \
-  SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field);             \
-  SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);            \
-  SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field);             \
-  SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field);             \
-} while (/*CONSTCOND*/ 0)
-
-/* Generates prototypes and inline functions */
-
-#define SPLAY_PROTOTYPE(name, type, field, cmp)                               \
-void name##_SPLAY(struct name *, struct type *);                              \
-void name##_SPLAY_MINMAX(struct name *, int);                                 \
-struct type *name##_SPLAY_INSERT(struct name *, struct type *);               \
-struct type *name##_SPLAY_REMOVE(struct name *, struct type *);               \
-                                                                              \
-/* Finds the node with the same key as elm */                                 \
-static __inline struct type *                                                 \
-name##_SPLAY_FIND(struct name *head, struct type *elm)                        \
-{                                                                             \
-  if (SPLAY_EMPTY(head))                                                      \
-    return(NULL);                                                             \
-  name##_SPLAY(head, elm);                                                    \
-  if ((cmp)(elm, (head)->sph_root) == 0)                                      \
-    return (head->sph_root);                                                  \
-  return (NULL);                                                              \
-}                                                                             \
-                                                                              \
-static __inline struct type *                                                 \
-name##_SPLAY_NEXT(struct name *head, struct type *elm)                        \
-{                                                                             \
-  name##_SPLAY(head, elm);                                                    \
-  if (SPLAY_RIGHT(elm, field) != NULL) {                                      \
-    elm = SPLAY_RIGHT(elm, field);                                            \
-    while (SPLAY_LEFT(elm, field) != NULL) {                                  \
-      elm = SPLAY_LEFT(elm, field);                                           \
-    }                                                                         \
-  } else                                                                      \
-    elm = NULL;                                                               \
-  return (elm);                                                               \
-}                                                                             \
-                                                                              \
-static __inline struct type *                                                 \
-name##_SPLAY_MIN_MAX(struct name *head, int val)                              \
-{                                                                             \
-  name##_SPLAY_MINMAX(head, val);                                             \
-  return (SPLAY_ROOT(head));                                                  \
-}
-
-/* Main splay operation.
- * Moves node close to the key of elm to top
- */
-#define SPLAY_GENERATE(name, type, field, cmp)                                \
-struct type *                                                                 \
-name##_SPLAY_INSERT(struct name *head, struct type *elm)                      \
-{                                                                             \
-    if (SPLAY_EMPTY(head)) {                                                  \
-      SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL;                \
-    } else {                                                                  \
-      int __comp;                                                             \
-      name##_SPLAY(head, elm);                                                \
-      __comp = (cmp)(elm, (head)->sph_root);                                  \
-      if(__comp < 0) {                                                        \
-        SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);         \
-        SPLAY_RIGHT(elm, field) = (head)->sph_root;                           \
-        SPLAY_LEFT((head)->sph_root, field) = NULL;                           \
-      } else if (__comp > 0) {                                                \
-        SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);       \
-        SPLAY_LEFT(elm, field) = (head)->sph_root;                            \
-        SPLAY_RIGHT((head)->sph_root, field) = NULL;                          \
-      } else                                                                  \
-        return ((head)->sph_root);                                            \
-    }                                                                         \
-    (head)->sph_root = (elm);                                                 \
-    return (NULL);                                                            \
-}                                                                             \
-                                                                              \
-struct type *                                                                 \
-name##_SPLAY_REMOVE(struct name *head, struct type *elm)                      \
-{                                                                             \
-  struct type *__tmp;                                                         \
-  if (SPLAY_EMPTY(head))                                                      \
-    return (NULL);                                                            \
-  name##_SPLAY(head, elm);                                                    \
-  if ((cmp)(elm, (head)->sph_root) == 0) {                                    \
-    if (SPLAY_LEFT((head)->sph_root, field) == NULL) {                        \
-      (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);                \
-    } else {                                                                  \
-      __tmp = SPLAY_RIGHT((head)->sph_root, field);                           \
-      (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);                 \
-      name##_SPLAY(head, elm);                                                \
-      SPLAY_RIGHT((head)->sph_root, field) = __tmp;                           \
-    }                                                                         \
-    return (elm);                                                             \
-  }                                                                           \
-  return (NULL);                                                              \
-}                                                                             \
-                                                                              \
-void                                                                          \
-name##_SPLAY(struct name *head, struct type *elm)                             \
-{                                                                             \
-  struct type __node, *__left, *__right, *__tmp;                              \
-  int __comp;                                                                 \
-                                                                              \
-  SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;            \
-  __left = __right = &__node;                                                 \
-                                                                              \
-  while ((__comp = (cmp)(elm, (head)->sph_root)) != 0) {                      \
-    if (__comp < 0) {                                                         \
-      __tmp = SPLAY_LEFT((head)->sph_root, field);                            \
-      if (__tmp == NULL)                                                      \
-        break;                                                                \
-      if ((cmp)(elm, __tmp) < 0){                                             \
-        SPLAY_ROTATE_RIGHT(head, __tmp, field);                               \
-        if (SPLAY_LEFT((head)->sph_root, field) == NULL)                      \
-          break;                                                              \
-      }                                                                       \
-      SPLAY_LINKLEFT(head, __right, field);                                   \
-    } else if (__comp > 0) {                                                  \
-      __tmp = SPLAY_RIGHT((head)->sph_root, field);                           \
-      if (__tmp == NULL)                                                      \
-        break;                                                                \
-      if ((cmp)(elm, __tmp) > 0){                                             \
-        SPLAY_ROTATE_LEFT(head, __tmp, field);                                \
-        if (SPLAY_RIGHT((head)->sph_root, field) == NULL)                     \
-          break;                                                              \
-      }                                                                       \
-      SPLAY_LINKRIGHT(head, __left, field);                                   \
-    }                                                                         \
-  }                                                                           \
-  SPLAY_ASSEMBLE(head, &__node, __left, __right, field);                      \
-}                                                                             \
-                                                                              \
-/* Splay with either the minimum or the maximum element                       \
- * Used to find minimum or maximum element in tree.                           \
- */                                                                           \
-void name##_SPLAY_MINMAX(struct name *head, int __comp)                       \
-{                                                                             \
-  struct type __node, *__left, *__right, *__tmp;                              \
-                                                                              \
-  SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;            \
-  __left = __right = &__node;                                                 \
-                                                                              \
-  while (1) {                                                                 \
-    if (__comp < 0) {                                                         \
-      __tmp = SPLAY_LEFT((head)->sph_root, field);                            \
-      if (__tmp == NULL)                                                      \
-        break;                                                                \
-      if (__comp < 0){                                                        \
-        SPLAY_ROTATE_RIGHT(head, __tmp, field);                               \
-        if (SPLAY_LEFT((head)->sph_root, field) == NULL)                      \
-          break;                                                              \
-      }                                                                       \
-      SPLAY_LINKLEFT(head, __right, field);                                   \
-    } else if (__comp > 0) {                                                  \
-      __tmp = SPLAY_RIGHT((head)->sph_root, field);                           \
-      if (__tmp == NULL)                                                      \
-        break;                                                                \
-      if (__comp > 0) {                                                       \
-        SPLAY_ROTATE_LEFT(head, __tmp, field);                                \
-        if (SPLAY_RIGHT((head)->sph_root, field) == NULL)                     \
-          break;                                                              \
-      }                                                                       \
-      SPLAY_LINKRIGHT(head, __left, field);                                   \
-    }                                                                         \
-  }                                                                           \
-  SPLAY_ASSEMBLE(head, &__node, __left, __right, field);                      \
-}
-
-#define SPLAY_NEGINF  -1
-#define SPLAY_INF     1
-
-#define SPLAY_INSERT(name, x, y)  name##_SPLAY_INSERT(x, y)
-#define SPLAY_REMOVE(name, x, y)  name##_SPLAY_REMOVE(x, y)
-#define SPLAY_FIND(name, x, y)    name##_SPLAY_FIND(x, y)
-#define SPLAY_NEXT(name, x, y)    name##_SPLAY_NEXT(x, y)
-#define SPLAY_MIN(name, x)        (SPLAY_EMPTY(x) ? NULL                      \
-                                  : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
-#define SPLAY_MAX(name, x)        (SPLAY_EMPTY(x) ? NULL                      \
-                                  : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
-
-#define SPLAY_FOREACH(x, name, head)                                          \
-  for ((x) = SPLAY_MIN(name, head);                                           \
-       (x) != NULL;                                                           \
-       (x) = SPLAY_NEXT(name, head, x))
-
-/* Macros that define a red-black tree */
-#define RB_HEAD(name, type)                                                   \
-struct name {                                                                 \
-  struct type *rbh_root; /* root of the tree */                               \
-}
-
-#define RB_INITIALIZER(root)                                                  \
-  { NULL }
-
-#define RB_INIT(root) do {                                                    \
-  (root)->rbh_root = NULL;                                                    \
-} while (/*CONSTCOND*/ 0)
-
-#define RB_BLACK  0
-#define RB_RED    1
-#define RB_ENTRY(type)                                                        \
-struct {                                                                      \
-  struct type *rbe_left;        /* left element */                            \
-  struct type *rbe_right;       /* right element */                           \
-  struct type *rbe_parent;      /* parent element */                          \
-  int rbe_color;                /* node color */                              \
-}
-
-#define RB_LEFT(elm, field)     (elm)->field.rbe_left
-#define RB_RIGHT(elm, field)    (elm)->field.rbe_right
-#define RB_PARENT(elm, field)   (elm)->field.rbe_parent
-#define RB_COLOR(elm, field)    (elm)->field.rbe_color
-#define RB_ROOT(head)           (head)->rbh_root
-#define RB_EMPTY(head)          (RB_ROOT(head) == NULL)
-
-#define RB_SET(elm, parent, field) do {                                       \
-  RB_PARENT(elm, field) = parent;                                             \
-  RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL;                          \
-  RB_COLOR(elm, field) = RB_RED;                                              \
-} while (/*CONSTCOND*/ 0)
-
-#define RB_SET_BLACKRED(black, red, field) do {                               \
-  RB_COLOR(black, field) = RB_BLACK;                                          \
-  RB_COLOR(red, field) = RB_RED;                                              \
-} while (/*CONSTCOND*/ 0)
-
-#ifndef RB_AUGMENT
-#define RB_AUGMENT(x)  do {} while (0)
-#endif
-
-#define RB_ROTATE_LEFT(head, elm, tmp, field) do {                            \
-  (tmp) = RB_RIGHT(elm, field);                                               \
-  if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) {                 \
-    RB_PARENT(RB_LEFT(tmp, field), field) = (elm);                            \
-  }                                                                           \
-  RB_AUGMENT(elm);                                                            \
-  if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {              \
-    if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                       \
-      RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                          \
-    else                                                                      \
-      RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                         \
-  } else                                                                      \
-    (head)->rbh_root = (tmp);                                                 \
-  RB_LEFT(tmp, field) = (elm);                                                \
-  RB_PARENT(elm, field) = (tmp);                                              \
-  RB_AUGMENT(tmp);                                                            \
-  if ((RB_PARENT(tmp, field)))                                                \
-    RB_AUGMENT(RB_PARENT(tmp, field));                                        \
-} while (/*CONSTCOND*/ 0)
-
-#define RB_ROTATE_RIGHT(head, elm, tmp, field) do {                           \
-  (tmp) = RB_LEFT(elm, field);                                                \
-  if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) {                 \
-    RB_PARENT(RB_RIGHT(tmp, field), field) = (elm);                           \
-  }                                                                           \
-  RB_AUGMENT(elm);                                                            \
-  if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {              \
-    if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                       \
-      RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                          \
-    else                                                                      \
-      RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                         \
-  } else                                                                      \
-    (head)->rbh_root = (tmp);                                                 \
-  RB_RIGHT(tmp, field) = (elm);                                               \
-  RB_PARENT(elm, field) = (tmp);                                              \
-  RB_AUGMENT(tmp);                                                            \
-  if ((RB_PARENT(tmp, field)))                                                \
-    RB_AUGMENT(RB_PARENT(tmp, field));                                        \
-} while (/*CONSTCOND*/ 0)
-
-/* Generates prototypes and inline functions */
-#define  RB_PROTOTYPE(name, type, field, cmp)                                 \
-  RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
-#define  RB_PROTOTYPE_STATIC(name, type, field, cmp)                          \
-  RB_PROTOTYPE_INTERNAL(name, type, field, cmp, UV__UNUSED static)
-#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)                   \
-attr void name##_RB_INSERT_COLOR(struct name *, struct type *);               \
-attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
-attr struct type *name##_RB_REMOVE(struct name *, struct type *);             \
-attr struct type *name##_RB_INSERT(struct name *, struct type *);             \
-attr struct type *name##_RB_FIND(struct name *, struct type *);               \
-attr struct type *name##_RB_NFIND(struct name *, struct type *);              \
-attr struct type *name##_RB_NEXT(struct type *);                              \
-attr struct type *name##_RB_PREV(struct type *);                              \
-attr struct type *name##_RB_MINMAX(struct name *, int);                       \
-                                                                              \
-
-/* Main rb operation.
- * Moves node close to the key of elm to top
- */
-#define  RB_GENERATE(name, type, field, cmp)                                  \
-  RB_GENERATE_INTERNAL(name, type, field, cmp,)
-#define  RB_GENERATE_STATIC(name, type, field, cmp)                           \
-  RB_GENERATE_INTERNAL(name, type, field, cmp, UV__UNUSED static)
-#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr)                    \
-attr void                                                                     \
-name##_RB_INSERT_COLOR(struct name *head, struct type *elm)                   \
-{                                                                             \
-  struct type *parent, *gparent, *tmp;                                        \
-  while ((parent = RB_PARENT(elm, field)) != NULL &&                          \
-      RB_COLOR(parent, field) == RB_RED) {                                    \
-    gparent = RB_PARENT(parent, field);                                       \
-    if (parent == RB_LEFT(gparent, field)) {                                  \
-      tmp = RB_RIGHT(gparent, field);                                         \
-      if (tmp && RB_COLOR(tmp, field) == RB_RED) {                            \
-        RB_COLOR(tmp, field) = RB_BLACK;                                      \
-        RB_SET_BLACKRED(parent, gparent, field);                              \
-        elm = gparent;                                                        \
-        continue;                                                             \
-      }                                                                       \
-      if (RB_RIGHT(parent, field) == elm) {                                   \
-        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
-        tmp = parent;                                                         \
-        parent = elm;                                                         \
-        elm = tmp;                                                            \
-      }                                                                       \
-      RB_SET_BLACKRED(parent, gparent, field);                                \
-      RB_ROTATE_RIGHT(head, gparent, tmp, field);                             \
-    } else {                                                                  \
-      tmp = RB_LEFT(gparent, field);                                          \
-      if (tmp && RB_COLOR(tmp, field) == RB_RED) {                            \
-        RB_COLOR(tmp, field) = RB_BLACK;                                      \
-        RB_SET_BLACKRED(parent, gparent, field);                              \
-        elm = gparent;                                                        \
-        continue;                                                             \
-      }                                                                       \
-      if (RB_LEFT(parent, field) == elm) {                                    \
-        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
-        tmp = parent;                                                         \
-        parent = elm;                                                         \
-        elm = tmp;                                                            \
-      }                                                                       \
-      RB_SET_BLACKRED(parent, gparent, field);                                \
-      RB_ROTATE_LEFT(head, gparent, tmp, field);                              \
-    }                                                                         \
-  }                                                                           \
-  RB_COLOR(head->rbh_root, field) = RB_BLACK;                                 \
-}                                                                             \
-                                                                              \
-attr void                                                                     \
-name##_RB_REMOVE_COLOR(struct name *head, struct type *parent,                \
-    struct type *elm)                                                         \
-{                                                                             \
-  struct type *tmp;                                                           \
-  while ((elm == NULL || RB_COLOR(elm, field) == RB_BLACK) &&                 \
-      elm != RB_ROOT(head)) {                                                 \
-    if (RB_LEFT(parent, field) == elm) {                                      \
-      tmp = RB_RIGHT(parent, field);                                          \
-      if (RB_COLOR(tmp, field) == RB_RED) {                                   \
-        RB_SET_BLACKRED(tmp, parent, field);                                  \
-        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
-        tmp = RB_RIGHT(parent, field);                                        \
-      }                                                                       \
-      if ((RB_LEFT(tmp, field) == NULL ||                                     \
-          RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                \
-          (RB_RIGHT(tmp, field) == NULL ||                                    \
-          RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {               \
-        RB_COLOR(tmp, field) = RB_RED;                                        \
-        elm = parent;                                                         \
-        parent = RB_PARENT(elm, field);                                       \
-      } else {                                                                \
-        if (RB_RIGHT(tmp, field) == NULL ||                                   \
-            RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {              \
-          struct type *oleft;                                                 \
-          if ((oleft = RB_LEFT(tmp, field))                                   \
-              != NULL)                                                        \
-            RB_COLOR(oleft, field) = RB_BLACK;                                \
-          RB_COLOR(tmp, field) = RB_RED;                                      \
-          RB_ROTATE_RIGHT(head, tmp, oleft, field);                           \
-          tmp = RB_RIGHT(parent, field);                                      \
-        }                                                                     \
-        RB_COLOR(tmp, field) = RB_COLOR(parent, field);                       \
-        RB_COLOR(parent, field) = RB_BLACK;                                   \
-        if (RB_RIGHT(tmp, field))                                             \
-          RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK;                   \
-        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
-        elm = RB_ROOT(head);                                                  \
-        break;                                                                \
-      }                                                                       \
-    } else {                                                                  \
-      tmp = RB_LEFT(parent, field);                                           \
-      if (RB_COLOR(tmp, field) == RB_RED) {                                   \
-        RB_SET_BLACKRED(tmp, parent, field);                                  \
-        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
-        tmp = RB_LEFT(parent, field);                                         \
-      }                                                                       \
-      if ((RB_LEFT(tmp, field) == NULL ||                                     \
-          RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                \
-          (RB_RIGHT(tmp, field) == NULL ||                                    \
-          RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {               \
-        RB_COLOR(tmp, field) = RB_RED;                                        \
-        elm = parent;                                                         \
-        parent = RB_PARENT(elm, field);                                       \
-      } else {                                                                \
-        if (RB_LEFT(tmp, field) == NULL ||                                    \
-            RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {               \
-          struct type *oright;                                                \
-          if ((oright = RB_RIGHT(tmp, field))                                 \
-              != NULL)                                                        \
-            RB_COLOR(oright, field) = RB_BLACK;                               \
-          RB_COLOR(tmp, field) = RB_RED;                                      \
-          RB_ROTATE_LEFT(head, tmp, oright, field);                           \
-          tmp = RB_LEFT(parent, field);                                       \
-        }                                                                     \
-        RB_COLOR(tmp, field) = RB_COLOR(parent, field);                       \
-        RB_COLOR(parent, field) = RB_BLACK;                                   \
-        if (RB_LEFT(tmp, field))                                              \
-          RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK;                    \
-        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
-        elm = RB_ROOT(head);                                                  \
-        break;                                                                \
-      }                                                                       \
-    }                                                                         \
-  }                                                                           \
-  if (elm)                                                                    \
-    RB_COLOR(elm, field) = RB_BLACK;                                          \
-}                                                                             \
-                                                                              \
-attr struct type *                                                            \
-name##_RB_REMOVE(struct name *head, struct type *elm)                         \
-{                                                                             \
-  struct type *child, *parent, *old = elm;                                    \
-  int color;                                                                  \
-  if (RB_LEFT(elm, field) == NULL)                                            \
-    child = RB_RIGHT(elm, field);                                             \
-  else if (RB_RIGHT(elm, field) == NULL)                                      \
-    child = RB_LEFT(elm, field);                                              \
-  else {                                                                      \
-    struct type *left;                                                        \
-    elm = RB_RIGHT(elm, field);                                               \
-    while ((left = RB_LEFT(elm, field)) != NULL)                              \
-      elm = left;                                                             \
-    child = RB_RIGHT(elm, field);                                             \
-    parent = RB_PARENT(elm, field);                                           \
-    color = RB_COLOR(elm, field);                                             \
-    if (child)                                                                \
-      RB_PARENT(child, field) = parent;                                       \
-    if (parent) {                                                             \
-      if (RB_LEFT(parent, field) == elm)                                      \
-        RB_LEFT(parent, field) = child;                                       \
-      else                                                                    \
-        RB_RIGHT(parent, field) = child;                                      \
-      RB_AUGMENT(parent);                                                     \
-    } else                                                                    \
-      RB_ROOT(head) = child;                                                  \
-    if (RB_PARENT(elm, field) == old)                                         \
-      parent = elm;                                                           \
-    (elm)->field = (old)->field;                                              \
-    if (RB_PARENT(old, field)) {                                              \
-      if (RB_LEFT(RB_PARENT(old, field), field) == old)                       \
-        RB_LEFT(RB_PARENT(old, field), field) = elm;                          \
-      else                                                                    \
-        RB_RIGHT(RB_PARENT(old, field), field) = elm;                         \
-      RB_AUGMENT(RB_PARENT(old, field));                                      \
-    } else                                                                    \
-      RB_ROOT(head) = elm;                                                    \
-    RB_PARENT(RB_LEFT(old, field), field) = elm;                              \
-    if (RB_RIGHT(old, field))                                                 \
-      RB_PARENT(RB_RIGHT(old, field), field) = elm;                           \
-    if (parent) {                                                             \
-      left = parent;                                                          \
-      do {                                                                    \
-        RB_AUGMENT(left);                                                     \
-      } while ((left = RB_PARENT(left, field)) != NULL);                      \
-    }                                                                         \
-    goto color;                                                               \
-  }                                                                           \
-  parent = RB_PARENT(elm, field);                                             \
-  color = RB_COLOR(elm, field);                                               \
-  if (child)                                                                  \
-    RB_PARENT(child, field) = parent;                                         \
-  if (parent) {                                                               \
-    if (RB_LEFT(parent, field) == elm)                                        \
-      RB_LEFT(parent, field) = child;                                         \
-    else                                                                      \
-      RB_RIGHT(parent, field) = child;                                        \
-    RB_AUGMENT(parent);                                                       \
-  } else                                                                      \
-    RB_ROOT(head) = child;                                                    \
-color:                                                                        \
-  if (color == RB_BLACK)                                                      \
-    name##_RB_REMOVE_COLOR(head, parent, child);                              \
-  return (old);                                                               \
-}                                                                             \
-                                                                              \
-/* Inserts a node into the RB tree */                                         \
-attr struct type *                                                            \
-name##_RB_INSERT(struct name *head, struct type *elm)                         \
-{                                                                             \
-  struct type *tmp;                                                           \
-  struct type *parent = NULL;                                                 \
-  int comp = 0;                                                               \
-  tmp = RB_ROOT(head);                                                        \
-  while (tmp) {                                                               \
-    parent = tmp;                                                             \
-    comp = (cmp)(elm, parent);                                                \
-    if (comp < 0)                                                             \
-      tmp = RB_LEFT(tmp, field);                                              \
-    else if (comp > 0)                                                        \
-      tmp = RB_RIGHT(tmp, field);                                             \
-    else                                                                      \
-      return (tmp);                                                           \
-  }                                                                           \
-  RB_SET(elm, parent, field);                                                 \
-  if (parent != NULL) {                                                       \
-    if (comp < 0)                                                             \
-      RB_LEFT(parent, field) = elm;                                           \
-    else                                                                      \
-      RB_RIGHT(parent, field) = elm;                                          \
-    RB_AUGMENT(parent);                                                       \
-  } else                                                                      \
-    RB_ROOT(head) = elm;                                                      \
-  name##_RB_INSERT_COLOR(head, elm);                                          \
-  return (NULL);                                                              \
-}                                                                             \
-                                                                              \
-/* Finds the node with the same key as elm */                                 \
-attr struct type *                                                            \
-name##_RB_FIND(struct name *head, struct type *elm)                           \
-{                                                                             \
-  struct type *tmp = RB_ROOT(head);                                           \
-  int comp;                                                                   \
-  while (tmp) {                                                               \
-    comp = cmp(elm, tmp);                                                     \
-    if (comp < 0)                                                             \
-      tmp = RB_LEFT(tmp, field);                                              \
-    else if (comp > 0)                                                        \
-      tmp = RB_RIGHT(tmp, field);                                             \
-    else                                                                      \
-      return (tmp);                                                           \
-  }                                                                           \
-  return (NULL);                                                              \
-}                                                                             \
-                                                                              \
-/* Finds the first node greater than or equal to the search key */            \
-attr struct type *                                                            \
-name##_RB_NFIND(struct name *head, struct type *elm)                          \
-{                                                                             \
-  struct type *tmp = RB_ROOT(head);                                           \
-  struct type *res = NULL;                                                    \
-  int comp;                                                                   \
-  while (tmp) {                                                               \
-    comp = cmp(elm, tmp);                                                     \
-    if (comp < 0) {                                                           \
-      res = tmp;                                                              \
-      tmp = RB_LEFT(tmp, field);                                              \
-    }                                                                         \
-    else if (comp > 0)                                                        \
-      tmp = RB_RIGHT(tmp, field);                                             \
-    else                                                                      \
-      return (tmp);                                                           \
-  }                                                                           \
-  return (res);                                                               \
-}                                                                             \
-                                                                              \
-/* ARGSUSED */                                                                \
-attr struct type *                                                            \
-name##_RB_NEXT(struct type *elm)                                              \
-{                                                                             \
-  if (RB_RIGHT(elm, field)) {                                                 \
-    elm = RB_RIGHT(elm, field);                                               \
-    while (RB_LEFT(elm, field))                                               \
-      elm = RB_LEFT(elm, field);                                              \
-  } else {                                                                    \
-    if (RB_PARENT(elm, field) &&                                              \
-        (elm == RB_LEFT(RB_PARENT(elm, field), field)))                       \
-      elm = RB_PARENT(elm, field);                                            \
-    else {                                                                    \
-      while (RB_PARENT(elm, field) &&                                         \
-          (elm == RB_RIGHT(RB_PARENT(elm, field), field)))                    \
-        elm = RB_PARENT(elm, field);                                          \
-      elm = RB_PARENT(elm, field);                                            \
-    }                                                                         \
-  }                                                                           \
-  return (elm);                                                               \
-}                                                                             \
-                                                                              \
-/* ARGSUSED */                                                                \
-attr struct type *                                                            \
-name##_RB_PREV(struct type *elm)                                              \
-{                                                                             \
-  if (RB_LEFT(elm, field)) {                                                  \
-    elm = RB_LEFT(elm, field);                                                \
-    while (RB_RIGHT(elm, field))                                              \
-      elm = RB_RIGHT(elm, field);                                             \
-  } else {                                                                    \
-    if (RB_PARENT(elm, field) &&                                              \
-        (elm == RB_RIGHT(RB_PARENT(elm, field), field)))                      \
-      elm = RB_PARENT(elm, field);                                            \
-    else {                                                                    \
-      while (RB_PARENT(elm, field) &&                                         \
-          (elm == RB_LEFT(RB_PARENT(elm, field), field)))                     \
-        elm = RB_PARENT(elm, field);                                          \
-      elm = RB_PARENT(elm, field);                                            \
-    }                                                                         \
-  }                                                                           \
-  return (elm);                                                               \
-}                                                                             \
-                                                                              \
-attr struct type *                                                            \
-name##_RB_MINMAX(struct name *head, int val)                                  \
-{                                                                             \
-  struct type *tmp = RB_ROOT(head);                                           \
-  struct type *parent = NULL;                                                 \
-  while (tmp) {                                                               \
-    parent = tmp;                                                             \
-    if (val < 0)                                                              \
-      tmp = RB_LEFT(tmp, field);                                              \
-    else                                                                      \
-      tmp = RB_RIGHT(tmp, field);                                             \
-  }                                                                           \
-  return (parent);                                                            \
-}
-
-#define RB_NEGINF   -1
-#define RB_INF      1
-
-#define RB_INSERT(name, x, y)   name##_RB_INSERT(x, y)
-#define RB_REMOVE(name, x, y)   name##_RB_REMOVE(x, y)
-#define RB_FIND(name, x, y)     name##_RB_FIND(x, y)
-#define RB_NFIND(name, x, y)    name##_RB_NFIND(x, y)
-#define RB_NEXT(name, x, y)     name##_RB_NEXT(y)
-#define RB_PREV(name, x, y)     name##_RB_PREV(y)
-#define RB_MIN(name, x)         name##_RB_MINMAX(x, RB_NEGINF)
-#define RB_MAX(name, x)         name##_RB_MINMAX(x, RB_INF)
-
-#define RB_FOREACH(x, name, head)                                             \
-  for ((x) = RB_MIN(name, head);                                              \
-       (x) != NULL;                                                           \
-       (x) = name##_RB_NEXT(x))
-
-#define RB_FOREACH_FROM(x, name, y)                                           \
-  for ((x) = (y);                                                             \
-      ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);                \
-       (x) = (y))
-
-#define RB_FOREACH_SAFE(x, name, head, y)                                     \
-  for ((x) = RB_MIN(name, head);                                              \
-      ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);                \
-       (x) = (y))
-
-#define RB_FOREACH_REVERSE(x, name, head)                                     \
-  for ((x) = RB_MAX(name, head);                                              \
-       (x) != NULL;                                                           \
-       (x) = name##_RB_PREV(x))
-
-#define RB_FOREACH_REVERSE_FROM(x, name, y)                                   \
-  for ((x) = (y);                                                             \
-      ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);                \
-       (x) = (y))
-
-#define RB_FOREACH_REVERSE_SAFE(x, name, head, y)                             \
-  for ((x) = RB_MAX(name, head);                                              \
-      ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);                \
-       (x) = (y))
-
-#endif  /* UV_TREE_H_ */
diff --git a/wpiutil/src/main/native/libuv/include/uv/unix.h b/wpiutil/src/main/native/libuv/include/uv/unix.h
deleted file mode 100644
index 504bab7..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/unix.h
+++ /dev/null
@@ -1,483 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_UNIX_H
-#define UV_UNIX_H
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <dirent.h>
-
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>  /* MAXHOSTNAMELEN on Solaris */
-
-#include <termios.h>
-#include <pwd.h>
-
-#if !defined(__MVS__)
-#include <semaphore.h>
-#include <sys/param.h> /* MAXHOSTNAMELEN on Linux and the BSDs */
-#endif
-#include <pthread.h>
-#include <signal.h>
-
-#include "uv/threadpool.h"
-
-#if defined(__linux__)
-# include "uv/linux.h"
-#elif defined(__APPLE__)
-# include "uv/darwin.h"
-#elif defined(__DragonFly__)       || \
-      defined(__FreeBSD__)         || \
-      defined(__FreeBSD_kernel__)  || \
-      defined(__OpenBSD__)         || \
-      defined(__NetBSD__)
-# include "uv/bsd.h"
-#elif defined(__PASE__)   || \
-      defined(__CYGWIN__) || \
-      defined(__MSYS__)   || \
-      defined(__GNU__)
-# include "uv/posix.h"
-#elif defined(__HAIKU__)
-# include "uv/posix.h"
-#endif
-
-#ifndef NI_MAXHOST
-# define NI_MAXHOST 1025
-#endif
-
-#ifndef NI_MAXSERV
-# define NI_MAXSERV 32
-#endif
-
-#ifndef UV_IO_PRIVATE_PLATFORM_FIELDS
-# define UV_IO_PRIVATE_PLATFORM_FIELDS /* empty */
-#endif
-
-struct uv__io_s;
-struct uv_loop_s;
-
-typedef void (*uv__io_cb)(struct uv_loop_s* loop,
-                          struct uv__io_s* w,
-                          unsigned int events);
-typedef struct uv__io_s uv__io_t;
-
-struct uv__io_s {
-  uv__io_cb cb;
-  void* pending_queue[2];
-  void* watcher_queue[2];
-  unsigned int pevents; /* Pending event mask i.e. mask at next tick. */
-  unsigned int events;  /* Current event mask. */
-  int fd;
-  UV_IO_PRIVATE_PLATFORM_FIELDS
-};
-
-#ifndef UV_PLATFORM_SEM_T
-# define UV_PLATFORM_SEM_T sem_t
-#endif
-
-#ifndef UV_PLATFORM_LOOP_FIELDS
-# define UV_PLATFORM_LOOP_FIELDS /* empty */
-#endif
-
-#ifndef UV_PLATFORM_FS_EVENT_FIELDS
-# define UV_PLATFORM_FS_EVENT_FIELDS /* empty */
-#endif
-
-#ifndef UV_STREAM_PRIVATE_PLATFORM_FIELDS
-# define UV_STREAM_PRIVATE_PLATFORM_FIELDS /* empty */
-#endif
-
-/* Note: May be cast to struct iovec. See writev(2). */
-typedef struct uv_buf_t {
-  char* base;
-  size_t len;
-} uv_buf_t;
-
-typedef int uv_file;
-typedef int uv_os_sock_t;
-typedef int uv_os_fd_t;
-typedef pid_t uv_pid_t;
-
-#define UV_ONCE_INIT PTHREAD_ONCE_INIT
-
-typedef pthread_once_t uv_once_t;
-typedef pthread_t uv_thread_t;
-typedef pthread_mutex_t uv_mutex_t;
-typedef pthread_rwlock_t uv_rwlock_t;
-typedef UV_PLATFORM_SEM_T uv_sem_t;
-typedef pthread_cond_t uv_cond_t;
-typedef pthread_key_t uv_key_t;
-
-/* Note: guard clauses should match uv_barrier_init's in src/unix/thread.c. */
-#if defined(_AIX) || \
-    defined(__OpenBSD__) || \
-    !defined(PTHREAD_BARRIER_SERIAL_THREAD)
-/* TODO(bnoordhuis) Merge into uv_barrier_t in v2. */
-struct _uv_barrier {
-  uv_mutex_t mutex;
-  uv_cond_t cond;
-  unsigned threshold;
-  unsigned in;
-  unsigned out;
-};
-
-typedef struct {
-  struct _uv_barrier* b;
-# if defined(PTHREAD_BARRIER_SERIAL_THREAD)
-  /* TODO(bnoordhuis) Remove padding in v2. */
-  char pad[sizeof(pthread_barrier_t) - sizeof(struct _uv_barrier*)];
-# endif
-} uv_barrier_t;
-#else
-typedef pthread_barrier_t uv_barrier_t;
-#endif
-
-/* Platform-specific definitions for uv_spawn support. */
-typedef gid_t uv_gid_t;
-typedef uid_t uv_uid_t;
-
-typedef struct dirent uv__dirent_t;
-
-#define UV_DIR_PRIVATE_FIELDS \
-  DIR* dir;
-
-#if defined(DT_UNKNOWN)
-# define HAVE_DIRENT_TYPES
-# if defined(DT_REG)
-#  define UV__DT_FILE DT_REG
-# else
-#  define UV__DT_FILE -1
-# endif
-# if defined(DT_DIR)
-#  define UV__DT_DIR DT_DIR
-# else
-#  define UV__DT_DIR -2
-# endif
-# if defined(DT_LNK)
-#  define UV__DT_LINK DT_LNK
-# else
-#  define UV__DT_LINK -3
-# endif
-# if defined(DT_FIFO)
-#  define UV__DT_FIFO DT_FIFO
-# else
-#  define UV__DT_FIFO -4
-# endif
-# if defined(DT_SOCK)
-#  define UV__DT_SOCKET DT_SOCK
-# else
-#  define UV__DT_SOCKET -5
-# endif
-# if defined(DT_CHR)
-#  define UV__DT_CHAR DT_CHR
-# else
-#  define UV__DT_CHAR -6
-# endif
-# if defined(DT_BLK)
-#  define UV__DT_BLOCK DT_BLK
-# else
-#  define UV__DT_BLOCK -7
-# endif
-#endif
-
-/* Platform-specific definitions for uv_dlopen support. */
-#define UV_DYNAMIC /* empty */
-
-typedef struct {
-  void* handle;
-  char* errmsg;
-} uv_lib_t;
-
-#define UV_LOOP_PRIVATE_FIELDS                                                \
-  unsigned long flags;                                                        \
-  int backend_fd;                                                             \
-  void* pending_queue[2];                                                     \
-  void* watcher_queue[2];                                                     \
-  void** watchers;                                                            \
-  unsigned int nwatchers;                                                     \
-  unsigned int nfds;                                                          \
-  void* wq[2];                                                                \
-  uv_mutex_t wq_mutex;                                                        \
-  uv_async_t wq_async;                                                        \
-  uv_rwlock_t cloexec_lock;                                                   \
-  uv_handle_t* closing_handles;                                               \
-  void* process_handles[2];                                                   \
-  void* prepare_handles[2];                                                   \
-  void* check_handles[2];                                                     \
-  void* idle_handles[2];                                                      \
-  void* async_handles[2];                                                     \
-  void (*async_unused)(void);  /* TODO(bnoordhuis) Remove in libuv v2. */     \
-  uv__io_t async_io_watcher;                                                  \
-  int async_wfd;                                                              \
-  struct {                                                                    \
-    void* min;                                                                \
-    unsigned int nelts;                                                       \
-  } timer_heap;                                                               \
-  uint64_t timer_counter;                                                     \
-  uint64_t time;                                                              \
-  int signal_pipefd[2];                                                       \
-  uv__io_t signal_io_watcher;                                                 \
-  uv_signal_t child_watcher;                                                  \
-  int emfile_fd;                                                              \
-  UV_PLATFORM_LOOP_FIELDS                                                     \
-
-#define UV_REQ_TYPE_PRIVATE /* empty */
-
-#define UV_REQ_PRIVATE_FIELDS  /* empty */
-
-#define UV_PRIVATE_REQ_TYPES /* empty */
-
-#define UV_WRITE_PRIVATE_FIELDS                                               \
-  void* queue[2];                                                             \
-  unsigned int write_index;                                                   \
-  uv_buf_t* bufs;                                                             \
-  unsigned int nbufs;                                                         \
-  int error;                                                                  \
-  uv_buf_t bufsml[4];                                                         \
-
-#define UV_CONNECT_PRIVATE_FIELDS                                             \
-  void* queue[2];                                                             \
-
-#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */
-
-#define UV_UDP_SEND_PRIVATE_FIELDS                                            \
-  void* queue[2];                                                             \
-  struct sockaddr_storage addr;                                               \
-  unsigned int nbufs;                                                         \
-  uv_buf_t* bufs;                                                             \
-  ssize_t status;                                                             \
-  uv_udp_send_cb send_cb;                                                     \
-  uv_buf_t bufsml[4];                                                         \
-
-#define UV_HANDLE_PRIVATE_FIELDS                                              \
-  uv_handle_t* next_closing;                                                  \
-  unsigned int flags;                                                         \
-
-#define UV_STREAM_PRIVATE_FIELDS                                              \
-  uv_connect_t *connect_req;                                                  \
-  uv_shutdown_t *shutdown_req;                                                \
-  uv__io_t io_watcher;                                                        \
-  void* write_queue[2];                                                       \
-  void* write_completed_queue[2];                                             \
-  uv_connection_cb connection_cb;                                             \
-  int delayed_error;                                                          \
-  int accepted_fd;                                                            \
-  void* queued_fds;                                                           \
-  UV_STREAM_PRIVATE_PLATFORM_FIELDS                                           \
-
-#define UV_TCP_PRIVATE_FIELDS /* empty */
-
-#define UV_UDP_PRIVATE_FIELDS                                                 \
-  uv_alloc_cb alloc_cb;                                                       \
-  uv_udp_recv_cb recv_cb;                                                     \
-  uv__io_t io_watcher;                                                        \
-  void* write_queue[2];                                                       \
-  void* write_completed_queue[2];                                             \
-
-#define UV_PIPE_PRIVATE_FIELDS                                                \
-  const char* pipe_fname; /* strdup'ed */
-
-#define UV_POLL_PRIVATE_FIELDS                                                \
-  uv__io_t io_watcher;
-
-#define UV_PREPARE_PRIVATE_FIELDS                                             \
-  uv_prepare_cb prepare_cb;                                                   \
-  void* queue[2];                                                             \
-
-#define UV_CHECK_PRIVATE_FIELDS                                               \
-  uv_check_cb check_cb;                                                       \
-  void* queue[2];                                                             \
-
-#define UV_IDLE_PRIVATE_FIELDS                                                \
-  uv_idle_cb idle_cb;                                                         \
-  void* queue[2];                                                             \
-
-#define UV_ASYNC_PRIVATE_FIELDS                                               \
-  uv_async_cb async_cb;                                                       \
-  void* queue[2];                                                             \
-  int pending;                                                                \
-
-#define UV_TIMER_PRIVATE_FIELDS                                               \
-  uv_timer_cb timer_cb;                                                       \
-  void* heap_node[3];                                                         \
-  uint64_t timeout;                                                           \
-  uint64_t repeat;                                                            \
-  uint64_t start_id;
-
-#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
-  struct uv__work work_req;                                                   \
-  uv_getaddrinfo_cb cb;                                                       \
-  struct addrinfo* hints;                                                     \
-  char* hostname;                                                             \
-  char* service;                                                              \
-  struct addrinfo* addrinfo;                                                  \
-  int retcode;
-
-#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
-  struct uv__work work_req;                                                   \
-  uv_getnameinfo_cb getnameinfo_cb;                                           \
-  struct sockaddr_storage storage;                                            \
-  int flags;                                                                  \
-  char host[NI_MAXHOST];                                                      \
-  char service[NI_MAXSERV];                                                   \
-  int retcode;
-
-#define UV_PROCESS_PRIVATE_FIELDS                                             \
-  void* queue[2];                                                             \
-  int status;                                                                 \
-
-#define UV_FS_PRIVATE_FIELDS                                                  \
-  const char *new_path;                                                       \
-  uv_file file;                                                               \
-  int flags;                                                                  \
-  mode_t mode;                                                                \
-  unsigned int nbufs;                                                         \
-  uv_buf_t* bufs;                                                             \
-  off_t off;                                                                  \
-  uv_uid_t uid;                                                               \
-  uv_gid_t gid;                                                               \
-  double atime;                                                               \
-  double mtime;                                                               \
-  struct uv__work work_req;                                                   \
-  uv_buf_t bufsml[4];                                                         \
-
-#define UV_WORK_PRIVATE_FIELDS                                                \
-  struct uv__work work_req;
-
-#define UV_TTY_PRIVATE_FIELDS                                                 \
-  struct termios orig_termios;                                                \
-  int mode;
-
-#define UV_SIGNAL_PRIVATE_FIELDS                                              \
-  /* RB_ENTRY(uv_signal_s) tree_entry; */                                     \
-  struct {                                                                    \
-    struct uv_signal_s* rbe_left;                                             \
-    struct uv_signal_s* rbe_right;                                            \
-    struct uv_signal_s* rbe_parent;                                           \
-    int rbe_color;                                                            \
-  } tree_entry;                                                               \
-  /* Use two counters here so we don have to fiddle with atomics. */          \
-  unsigned int caught_signals;                                                \
-  unsigned int dispatched_signals;
-
-#define UV_FS_EVENT_PRIVATE_FIELDS                                            \
-  uv_fs_event_cb cb;                                                          \
-  UV_PLATFORM_FS_EVENT_FIELDS                                                 \
-
-/* fs open() flags supported on this platform: */
-#if defined(O_APPEND)
-# define UV_FS_O_APPEND       O_APPEND
-#else
-# define UV_FS_O_APPEND       0
-#endif
-#if defined(O_CREAT)
-# define UV_FS_O_CREAT        O_CREAT
-#else
-# define UV_FS_O_CREAT        0
-#endif
-#if defined(O_DIRECT)
-# define UV_FS_O_DIRECT       O_DIRECT
-#else
-# define UV_FS_O_DIRECT       0
-#endif
-#if defined(O_DIRECTORY)
-# define UV_FS_O_DIRECTORY    O_DIRECTORY
-#else
-# define UV_FS_O_DIRECTORY    0
-#endif
-#if defined(O_DSYNC)
-# define UV_FS_O_DSYNC        O_DSYNC
-#else
-# define UV_FS_O_DSYNC        0
-#endif
-#if defined(O_EXCL)
-# define UV_FS_O_EXCL         O_EXCL
-#else
-# define UV_FS_O_EXCL         0
-#endif
-#if defined(O_EXLOCK)
-# define UV_FS_O_EXLOCK       O_EXLOCK
-#else
-# define UV_FS_O_EXLOCK       0
-#endif
-#if defined(O_NOATIME)
-# define UV_FS_O_NOATIME      O_NOATIME
-#else
-# define UV_FS_O_NOATIME      0
-#endif
-#if defined(O_NOCTTY)
-# define UV_FS_O_NOCTTY       O_NOCTTY
-#else
-# define UV_FS_O_NOCTTY       0
-#endif
-#if defined(O_NOFOLLOW)
-# define UV_FS_O_NOFOLLOW     O_NOFOLLOW
-#else
-# define UV_FS_O_NOFOLLOW     0
-#endif
-#if defined(O_NONBLOCK)
-# define UV_FS_O_NONBLOCK     O_NONBLOCK
-#else
-# define UV_FS_O_NONBLOCK     0
-#endif
-#if defined(O_RDONLY)
-# define UV_FS_O_RDONLY       O_RDONLY
-#else
-# define UV_FS_O_RDONLY       0
-#endif
-#if defined(O_RDWR)
-# define UV_FS_O_RDWR         O_RDWR
-#else
-# define UV_FS_O_RDWR         0
-#endif
-#if defined(O_SYMLINK)
-# define UV_FS_O_SYMLINK      O_SYMLINK
-#else
-# define UV_FS_O_SYMLINK      0
-#endif
-#if defined(O_SYNC)
-# define UV_FS_O_SYNC         O_SYNC
-#else
-# define UV_FS_O_SYNC         0
-#endif
-#if defined(O_TRUNC)
-# define UV_FS_O_TRUNC        O_TRUNC
-#else
-# define UV_FS_O_TRUNC        0
-#endif
-#if defined(O_WRONLY)
-# define UV_FS_O_WRONLY       O_WRONLY
-#else
-# define UV_FS_O_WRONLY       0
-#endif
-
-/* fs open() flags supported on other platforms: */
-#define UV_FS_O_RANDOM        0
-#define UV_FS_O_SHORT_LIVED   0
-#define UV_FS_O_SEQUENTIAL    0
-#define UV_FS_O_TEMPORARY     0
-
-#endif /* UV_UNIX_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/version.h b/wpiutil/src/main/native/libuv/include/uv/version.h
deleted file mode 100644
index bf992d2..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/version.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_VERSION_H
-#define UV_VERSION_H
-
- /*
- * Versions with the same major number are ABI stable. API is allowed to
- * evolve between minor releases, but only in a backwards compatible way.
- * Make sure you update the -soname directives in configure.ac
- * and uv.gyp whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but
- * not UV_VERSION_PATCH.)
- */
-
-#define UV_VERSION_MAJOR 1
-#define UV_VERSION_MINOR 30
-#define UV_VERSION_PATCH 1
-#define UV_VERSION_IS_RELEASE 1
-#define UV_VERSION_SUFFIX ""
-
-#define UV_VERSION_HEX  ((UV_VERSION_MAJOR << 16) | \
-                         (UV_VERSION_MINOR <<  8) | \
-                         (UV_VERSION_PATCH))
-
-#endif /* UV_VERSION_H */
diff --git a/wpiutil/src/main/native/libuv/include/uv/win.h b/wpiutil/src/main/native/libuv/include/uv/win.h
deleted file mode 100644
index ca5242f..0000000
--- a/wpiutil/src/main/native/libuv/include/uv/win.h
+++ /dev/null
@@ -1,691 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef _WIN32_WINNT
-# define _WIN32_WINNT   0x0600
-#endif
-
-#if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)
-typedef intptr_t ssize_t;
-# define SSIZE_MAX INTPTR_MAX
-# define _SSIZE_T_
-# define _SSIZE_T_DEFINED
-#endif
-
-#include <winsock2.h>
-
-#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
-typedef struct pollfd {
-  SOCKET fd;
-  short  events;
-  short  revents;
-} WSAPOLLFD, *PWSAPOLLFD, *LPWSAPOLLFD;
-#endif
-
-#ifndef LOCALE_INVARIANT
-# define LOCALE_INVARIANT 0x007f
-#endif
-
-#include <mswsock.h>
-#include <ws2tcpip.h>
-#include <windows.h>
-
-#include <process.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-
-#include <stdint.h>
-
-#include "uv/tree.h"
-#include "uv/threadpool.h"
-
-#define MAX_PIPENAME_LEN 256
-
-#ifndef S_IFLNK
-# define S_IFLNK 0xA000
-#endif
-
-/* Additional signals supported by uv_signal and or uv_kill. The CRT defines
- * the following signals already:
- *
- *   #define SIGINT           2
- *   #define SIGILL           4
- *   #define SIGABRT_COMPAT   6
- *   #define SIGFPE           8
- *   #define SIGSEGV         11
- *   #define SIGTERM         15
- *   #define SIGBREAK        21
- *   #define SIGABRT         22
- *
- * The additional signals have values that are common on other Unix
- * variants (Linux and Darwin)
- */
-#define SIGHUP                1
-#define SIGKILL               9
-#define SIGWINCH             28
-
-/* Redefine NSIG to take SIGWINCH into consideration */
-#if defined(NSIG) && NSIG <= SIGWINCH
-# undef NSIG
-#endif
-#ifndef NSIG
-# define NSIG SIGWINCH + 1
-#endif
-
-/* The CRT defines SIGABRT_COMPAT as 6, which equals SIGABRT on many unix-like
- * platforms. However MinGW doesn't define it, so we do. */
-#ifndef SIGABRT_COMPAT
-# define SIGABRT_COMPAT       6
-#endif
-
-/*
- * Guids and typedefs for winsock extension functions
- * Mingw32 doesn't have these :-(
- */
-#ifndef WSAID_ACCEPTEX
-# define WSAID_ACCEPTEX                                                       \
-         {0xb5367df1, 0xcbac, 0x11cf,                                         \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-# define WSAID_CONNECTEX                                                      \
-         {0x25a207b9, 0xddf3, 0x4660,                                         \
-         {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}
-
-# define WSAID_GETACCEPTEXSOCKADDRS                                           \
-         {0xb5367df2, 0xcbac, 0x11cf,                                         \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-# define WSAID_DISCONNECTEX                                                   \
-         {0x7fda2e11, 0x8630, 0x436f,                                         \
-         {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}
-
-# define WSAID_TRANSMITFILE                                                   \
-         {0xb5367df0, 0xcbac, 0x11cf,                                         \
-         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
-
-  typedef BOOL (PASCAL *LPFN_ACCEPTEX)
-                      (SOCKET sListenSocket,
-                       SOCKET sAcceptSocket,
-                       PVOID lpOutputBuffer,
-                       DWORD dwReceiveDataLength,
-                       DWORD dwLocalAddressLength,
-                       DWORD dwRemoteAddressLength,
-                       LPDWORD lpdwBytesReceived,
-                       LPOVERLAPPED lpOverlapped);
-
-  typedef BOOL (PASCAL *LPFN_CONNECTEX)
-                      (SOCKET s,
-                       const struct sockaddr* name,
-                       int namelen,
-                       PVOID lpSendBuffer,
-                       DWORD dwSendDataLength,
-                       LPDWORD lpdwBytesSent,
-                       LPOVERLAPPED lpOverlapped);
-
-  typedef void (PASCAL *LPFN_GETACCEPTEXSOCKADDRS)
-                      (PVOID lpOutputBuffer,
-                       DWORD dwReceiveDataLength,
-                       DWORD dwLocalAddressLength,
-                       DWORD dwRemoteAddressLength,
-                       LPSOCKADDR* LocalSockaddr,
-                       LPINT LocalSockaddrLength,
-                       LPSOCKADDR* RemoteSockaddr,
-                       LPINT RemoteSockaddrLength);
-
-  typedef BOOL (PASCAL *LPFN_DISCONNECTEX)
-                      (SOCKET hSocket,
-                       LPOVERLAPPED lpOverlapped,
-                       DWORD dwFlags,
-                       DWORD reserved);
-
-  typedef BOOL (PASCAL *LPFN_TRANSMITFILE)
-                      (SOCKET hSocket,
-                       HANDLE hFile,
-                       DWORD nNumberOfBytesToWrite,
-                       DWORD nNumberOfBytesPerSend,
-                       LPOVERLAPPED lpOverlapped,
-                       LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
-                       DWORD dwFlags);
-
-  typedef PVOID RTL_SRWLOCK;
-  typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
-#endif
-
-typedef int (WSAAPI* LPFN_WSARECV)
-            (SOCKET socket,
-             LPWSABUF buffers,
-             DWORD buffer_count,
-             LPDWORD bytes,
-             LPDWORD flags,
-             LPWSAOVERLAPPED overlapped,
-             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
-
-typedef int (WSAAPI* LPFN_WSARECVFROM)
-            (SOCKET socket,
-             LPWSABUF buffers,
-             DWORD buffer_count,
-             LPDWORD bytes,
-             LPDWORD flags,
-             struct sockaddr* addr,
-             LPINT addr_len,
-             LPWSAOVERLAPPED overlapped,
-             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
-
-#pragma warning(push)
-#pragma warning(disable : 28251)
-
-#ifndef _NTDEF_
-  typedef LONG NTSTATUS;
-  typedef NTSTATUS *PNTSTATUS;
-#endif
-
-#pragma warning(pop)
-
-#ifndef RTL_CONDITION_VARIABLE_INIT
-  typedef PVOID CONDITION_VARIABLE, *PCONDITION_VARIABLE;
-#endif
-
-typedef struct _AFD_POLL_HANDLE_INFO {
-  HANDLE Handle;
-  ULONG Events;
-  NTSTATUS Status;
-} AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO;
-
-typedef struct _AFD_POLL_INFO {
-  LARGE_INTEGER Timeout;
-  ULONG NumberOfHandles;
-  ULONG Exclusive;
-  AFD_POLL_HANDLE_INFO Handles[1];
-} AFD_POLL_INFO, *PAFD_POLL_INFO;
-
-#define UV_MSAFD_PROVIDER_COUNT 3
-
-
-/**
- * It should be possible to cast uv_buf_t[] to WSABUF[]
- * see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx
- */
-typedef struct uv_buf_t {
-  ULONG len;
-  char* base;
-} uv_buf_t;
-
-typedef int uv_file;
-typedef SOCKET uv_os_sock_t;
-typedef HANDLE uv_os_fd_t;
-typedef int uv_pid_t;
-
-typedef HANDLE uv_thread_t;
-
-typedef HANDLE uv_sem_t;
-
-typedef CRITICAL_SECTION uv_mutex_t;
-
-/* This condition variable implementation is based on the SetEvent solution
- * (section 3.2) at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
- * We could not use the SignalObjectAndWait solution (section 3.4) because
- * it want the 2nd argument (type uv_mutex_t) of uv_cond_wait() and
- * uv_cond_timedwait() to be HANDLEs, but we use CRITICAL_SECTIONs.
- */
-
-typedef union {
-  CONDITION_VARIABLE cond_var;
-  struct {
-    unsigned int waiters_count;
-    CRITICAL_SECTION waiters_count_lock;
-    HANDLE signal_event;
-    HANDLE broadcast_event;
-  } unused_; /* TODO: retained for ABI compatibility; remove me in v2.x. */
-} uv_cond_t;
-
-typedef union {
-  struct {
-    unsigned int num_readers_;
-    CRITICAL_SECTION num_readers_lock_;
-    HANDLE write_semaphore_;
-  } state_;
-  /* TODO: remove me in v2.x. */
-  struct {
-    SRWLOCK unused_;
-  } unused1_;
-  /* TODO: remove me in v2.x. */
-  struct {
-    uv_mutex_t unused1_;
-    uv_mutex_t unused2_;
-  } unused2_;
-} uv_rwlock_t;
-
-typedef struct {
-  unsigned int n;
-  unsigned int count;
-  uv_mutex_t mutex;
-  uv_sem_t turnstile1;
-  uv_sem_t turnstile2;
-} uv_barrier_t;
-
-typedef struct {
-  DWORD tls_index;
-} uv_key_t;
-
-#define UV_ONCE_INIT { 0, NULL }
-
-typedef struct uv_once_s {
-  unsigned char ran;
-  HANDLE event;
-} uv_once_t;
-
-/* Platform-specific definitions for uv_spawn support. */
-typedef unsigned char uv_uid_t;
-typedef unsigned char uv_gid_t;
-
-typedef struct uv__dirent_s {
-  int d_type;
-  char d_name[1];
-} uv__dirent_t;
-
-#define UV_DIR_PRIVATE_FIELDS \
-  HANDLE dir_handle;          \
-  WIN32_FIND_DATAW find_data; \
-  BOOL need_find_call;
-
-#define HAVE_DIRENT_TYPES
-#define UV__DT_DIR     UV_DIRENT_DIR
-#define UV__DT_FILE    UV_DIRENT_FILE
-#define UV__DT_LINK    UV_DIRENT_LINK
-#define UV__DT_FIFO    UV_DIRENT_FIFO
-#define UV__DT_SOCKET  UV_DIRENT_SOCKET
-#define UV__DT_CHAR    UV_DIRENT_CHAR
-#define UV__DT_BLOCK   UV_DIRENT_BLOCK
-
-/* Platform-specific definitions for uv_dlopen support. */
-#define UV_DYNAMIC FAR WINAPI
-typedef struct {
-  HMODULE handle;
-  char* errmsg;
-} uv_lib_t;
-
-#define UV_LOOP_PRIVATE_FIELDS                                                \
-    /* The loop's I/O completion port */                                      \
-  HANDLE iocp;                                                                \
-  /* The current time according to the event loop. in msecs. */               \
-  uint64_t time;                                                              \
-  /* Tail of a single-linked circular queue of pending reqs. If the queue */  \
-  /* is empty, tail_ is NULL. If there is only one item, */                   \
-  /* tail_->next_req == tail_ */                                              \
-  uv_req_t* pending_reqs_tail;                                                \
-  /* Head of a single-linked list of closed handles */                        \
-  uv_handle_t* endgame_handles;                                               \
-  /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */     \
-  void* timer_heap;                                                           \
-    /* Lists of active loop (prepare / check / idle) watchers */              \
-  uv_prepare_t* prepare_handles;                                              \
-  uv_check_t* check_handles;                                                  \
-  uv_idle_t* idle_handles;                                                    \
-  /* This pointer will refer to the prepare/check/idle handle whose */        \
-  /* callback is scheduled to be called next. This is needed to allow */      \
-  /* safe removal from one of the lists above while that list being */        \
-  /* iterated over. */                                                        \
-  uv_prepare_t* next_prepare_handle;                                          \
-  uv_check_t* next_check_handle;                                              \
-  uv_idle_t* next_idle_handle;                                                \
-  /* This handle holds the peer sockets for the fast variant of uv_poll_t */  \
-  SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT];                          \
-  /* Counter to keep track of active tcp streams */                           \
-  unsigned int active_tcp_streams;                                            \
-  /* Counter to keep track of active udp streams */                           \
-  unsigned int active_udp_streams;                                            \
-  /* Counter to started timer */                                              \
-  uint64_t timer_counter;                                                     \
-  /* Threadpool */                                                            \
-  void* wq[2];                                                                \
-  uv_mutex_t wq_mutex;                                                        \
-  uv_async_t wq_async;
-
-#define UV_REQ_TYPE_PRIVATE                                                   \
-  /* TODO: remove the req suffix */                                           \
-  UV_ACCEPT,                                                                  \
-  UV_FS_EVENT_REQ,                                                            \
-  UV_POLL_REQ,                                                                \
-  UV_PROCESS_EXIT,                                                            \
-  UV_READ,                                                                    \
-  UV_UDP_RECV,                                                                \
-  UV_WAKEUP,                                                                  \
-  UV_SIGNAL_REQ,
-
-#define UV_REQ_PRIVATE_FIELDS                                                 \
-  union {                                                                     \
-    /* Used by I/O operations */                                              \
-    struct {                                                                  \
-      OVERLAPPED overlapped;                                                  \
-      size_t queued_bytes;                                                    \
-    } io;                                                                     \
-  } u;                                                                        \
-  struct uv_req_s* next_req;
-
-#define UV_WRITE_PRIVATE_FIELDS \
-  int coalesced;                \
-  uv_buf_t write_buffer;        \
-  HANDLE event_handle;          \
-  HANDLE wait_handle;
-
-#define UV_CONNECT_PRIVATE_FIELDS                                             \
-  /* empty */
-
-#define UV_SHUTDOWN_PRIVATE_FIELDS                                            \
-  /* empty */
-
-#define UV_UDP_SEND_PRIVATE_FIELDS                                            \
-  /* empty */
-
-#define UV_PRIVATE_REQ_TYPES                                                  \
-  typedef struct uv_pipe_accept_s {                                           \
-    UV_REQ_FIELDS                                                             \
-    HANDLE pipeHandle;                                                        \
-    struct uv_pipe_accept_s* next_pending;                                    \
-  } uv_pipe_accept_t;                                                         \
-                                                                              \
-  typedef struct uv_tcp_accept_s {                                            \
-    UV_REQ_FIELDS                                                             \
-    SOCKET accept_socket;                                                     \
-    char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32];             \
-    HANDLE event_handle;                                                      \
-    HANDLE wait_handle;                                                       \
-    struct uv_tcp_accept_s* next_pending;                                     \
-  } uv_tcp_accept_t;                                                          \
-                                                                              \
-  typedef struct uv_read_s {                                                  \
-    UV_REQ_FIELDS                                                             \
-    HANDLE event_handle;                                                      \
-    HANDLE wait_handle;                                                       \
-  } uv_read_t;
-
-#define uv_stream_connection_fields                                           \
-  unsigned int write_reqs_pending;                                            \
-  uv_shutdown_t* shutdown_req;
-
-#define uv_stream_server_fields                                               \
-  uv_connection_cb connection_cb;
-
-#define UV_STREAM_PRIVATE_FIELDS                                              \
-  unsigned int reqs_pending;                                                  \
-  int activecnt;                                                              \
-  uv_read_t read_req;                                                         \
-  union {                                                                     \
-    struct { uv_stream_connection_fields } conn;                              \
-    struct { uv_stream_server_fields     } serv;                              \
-  } stream;
-
-#define uv_tcp_server_fields                                                  \
-  uv_tcp_accept_t* accept_reqs;                                               \
-  unsigned int processed_accepts;                                             \
-  uv_tcp_accept_t* pending_accepts;                                           \
-  LPFN_ACCEPTEX func_acceptex;
-
-#define uv_tcp_connection_fields                                              \
-  uv_buf_t read_buffer;                                                       \
-  LPFN_CONNECTEX func_connectex;
-
-#define UV_TCP_PRIVATE_FIELDS                                                 \
-  SOCKET socket;                                                              \
-  int delayed_error;                                                          \
-  union {                                                                     \
-    struct { uv_tcp_server_fields } serv;                                     \
-    struct { uv_tcp_connection_fields } conn;                                 \
-  } tcp;
-
-#define UV_UDP_PRIVATE_FIELDS                                                 \
-  SOCKET socket;                                                              \
-  unsigned int reqs_pending;                                                  \
-  int activecnt;                                                              \
-  uv_req_t recv_req;                                                          \
-  uv_buf_t recv_buffer;                                                       \
-  struct sockaddr_storage recv_from;                                          \
-  int recv_from_len;                                                          \
-  uv_udp_recv_cb recv_cb;                                                     \
-  uv_alloc_cb alloc_cb;                                                       \
-  LPFN_WSARECV func_wsarecv;                                                  \
-  LPFN_WSARECVFROM func_wsarecvfrom;
-
-#define uv_pipe_server_fields                                                 \
-  int pending_instances;                                                      \
-  uv_pipe_accept_t* accept_reqs;                                              \
-  uv_pipe_accept_t* pending_accepts;
-
-#define uv_pipe_connection_fields                                             \
-  uv_timer_t* eof_timer;                                                      \
-  uv_write_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
-  DWORD ipc_remote_pid;                                                       \
-  union {                                                                     \
-    uint32_t payload_remaining;                                               \
-    uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
-  } ipc_data_frame;                                                           \
-  void* ipc_xfer_queue[2];                                                    \
-  int ipc_xfer_queue_length;                                                  \
-  uv_write_t* non_overlapped_writes_tail;                                     \
-  CRITICAL_SECTION readfile_thread_lock;                                      \
-  volatile HANDLE readfile_thread_handle;
-
-#define UV_PIPE_PRIVATE_FIELDS                                                \
-  HANDLE handle;                                                              \
-  WCHAR* name;                                                                \
-  union {                                                                     \
-    struct { uv_pipe_server_fields } serv;                                    \
-    struct { uv_pipe_connection_fields } conn;                                \
-  } pipe;
-
-/* TODO: put the parser states in an union - TTY handles are always half-duplex
- * so read-state can safely overlap write-state. */
-#define UV_TTY_PRIVATE_FIELDS                                                 \
-  HANDLE handle;                                                              \
-  union {                                                                     \
-    struct {                                                                  \
-      /* Used for readable TTY handles */                                     \
-      /* TODO: remove me in v2.x. */                                          \
-      HANDLE unused_;                                                         \
-      uv_buf_t read_line_buffer;                                              \
-      HANDLE read_raw_wait;                                                   \
-      /* Fields used for translating win keystrokes into vt100 characters */  \
-      char last_key[8];                                                       \
-      unsigned char last_key_offset;                                          \
-      unsigned char last_key_len;                                             \
-      WCHAR last_utf16_high_surrogate;                                        \
-      INPUT_RECORD last_input_record;                                         \
-    } rd;                                                                     \
-    struct {                                                                  \
-      /* Used for writable TTY handles */                                     \
-      /* utf8-to-utf16 conversion state */                                    \
-      unsigned int utf8_codepoint;                                            \
-      unsigned char utf8_bytes_left;                                          \
-      /* eol conversion state */                                              \
-      unsigned char previous_eol;                                             \
-      /* ansi parser state */                                                 \
-      unsigned char ansi_parser_state;                                        \
-      unsigned char ansi_csi_argc;                                            \
-      unsigned short ansi_csi_argv[4];                                        \
-      COORD saved_position;                                                   \
-      WORD saved_attributes;                                                  \
-    } wr;                                                                     \
-  } tty;
-
-#define UV_POLL_PRIVATE_FIELDS                                                \
-  SOCKET socket;                                                              \
-  /* Used in fast mode */                                                     \
-  SOCKET peer_socket;                                                         \
-  AFD_POLL_INFO afd_poll_info_1;                                              \
-  AFD_POLL_INFO afd_poll_info_2;                                              \
-  /* Used in fast and slow mode. */                                           \
-  uv_req_t poll_req_1;                                                        \
-  uv_req_t poll_req_2;                                                        \
-  unsigned char submitted_events_1;                                           \
-  unsigned char submitted_events_2;                                           \
-  unsigned char mask_events_1;                                                \
-  unsigned char mask_events_2;                                                \
-  unsigned char events;
-
-#define UV_TIMER_PRIVATE_FIELDS                                               \
-  void* heap_node[3];                                                         \
-  int unused;                                                                 \
-  uint64_t timeout;                                                           \
-  uint64_t repeat;                                                            \
-  uint64_t start_id;                                                          \
-  uv_timer_cb timer_cb;
-
-#define UV_ASYNC_PRIVATE_FIELDS                                               \
-  struct uv_req_s async_req;                                                  \
-  uv_async_cb async_cb;                                                       \
-  /* char to avoid alignment issues */                                        \
-  char volatile async_sent;
-
-#define UV_PREPARE_PRIVATE_FIELDS                                             \
-  uv_prepare_t* prepare_prev;                                                 \
-  uv_prepare_t* prepare_next;                                                 \
-  uv_prepare_cb prepare_cb;
-
-#define UV_CHECK_PRIVATE_FIELDS                                               \
-  uv_check_t* check_prev;                                                     \
-  uv_check_t* check_next;                                                     \
-  uv_check_cb check_cb;
-
-#define UV_IDLE_PRIVATE_FIELDS                                                \
-  uv_idle_t* idle_prev;                                                       \
-  uv_idle_t* idle_next;                                                       \
-  uv_idle_cb idle_cb;
-
-#define UV_HANDLE_PRIVATE_FIELDS                                              \
-  uv_handle_t* endgame_next;                                                  \
-  unsigned int flags;
-
-#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
-  struct uv__work work_req;                                                   \
-  uv_getaddrinfo_cb getaddrinfo_cb;                                           \
-  void* alloc;                                                                \
-  WCHAR* node;                                                                \
-  WCHAR* service;                                                             \
-  /* The addrinfoW field is used to store a pointer to the hints, and    */   \
-  /* later on to store the result of GetAddrInfoW. The final result will */   \
-  /* be converted to struct addrinfo* and stored in the addrinfo field.  */   \
-  struct addrinfoW* addrinfow;                                                \
-  struct addrinfo* addrinfo;                                                  \
-  int retcode;
-
-#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
-  struct uv__work work_req;                                                   \
-  uv_getnameinfo_cb getnameinfo_cb;                                           \
-  struct sockaddr_storage storage;                                            \
-  int flags;                                                                  \
-  char host[NI_MAXHOST];                                                      \
-  char service[NI_MAXSERV];                                                   \
-  int retcode;
-
-#define UV_PROCESS_PRIVATE_FIELDS                                             \
-  struct uv_process_exit_s {                                                  \
-    UV_REQ_FIELDS                                                             \
-  } exit_req;                                                                 \
-  BYTE* child_stdio_buffer;                                                   \
-  int exit_signal;                                                            \
-  HANDLE wait_handle;                                                         \
-  HANDLE process_handle;                                                      \
-  volatile char exit_cb_pending;
-
-#define UV_FS_PRIVATE_FIELDS                                                  \
-  struct uv__work work_req;                                                   \
-  int flags;                                                                  \
-  DWORD sys_errno_;                                                           \
-  union {                                                                     \
-    /* TODO: remove me in 0.9. */                                             \
-    WCHAR* pathw;                                                             \
-    int fd;                                                                   \
-  } file;                                                                     \
-  union {                                                                     \
-    struct {                                                                  \
-      int mode;                                                               \
-      WCHAR* new_pathw;                                                       \
-      int file_flags;                                                         \
-      int fd_out;                                                             \
-      unsigned int nbufs;                                                     \
-      uv_buf_t* bufs;                                                         \
-      int64_t offset;                                                         \
-      uv_buf_t bufsml[4];                                                     \
-    } info;                                                                   \
-    struct {                                                                  \
-      double atime;                                                           \
-      double mtime;                                                           \
-    } time;                                                                   \
-  } fs;
-
-#define UV_WORK_PRIVATE_FIELDS                                                \
-  struct uv__work work_req;
-
-#define UV_FS_EVENT_PRIVATE_FIELDS                                            \
-  struct uv_fs_event_req_s {                                                  \
-    UV_REQ_FIELDS                                                             \
-  } req;                                                                      \
-  HANDLE dir_handle;                                                          \
-  int req_pending;                                                            \
-  uv_fs_event_cb cb;                                                          \
-  WCHAR* filew;                                                               \
-  WCHAR* short_filew;                                                         \
-  WCHAR* dirw;                                                                \
-  char* buffer;
-
-#define UV_SIGNAL_PRIVATE_FIELDS                                              \
-  RB_ENTRY(uv_signal_s) tree_entry;                                           \
-  struct uv_req_s signal_req;                                                 \
-  unsigned long pending_signum;
-
-#ifndef F_OK
-#define F_OK 0
-#endif
-#ifndef R_OK
-#define R_OK 4
-#endif
-#ifndef W_OK
-#define W_OK 2
-#endif
-#ifndef X_OK
-#define X_OK 1
-#endif
-
-/* fs open() flags supported on this platform: */
-#define UV_FS_O_APPEND       _O_APPEND
-#define UV_FS_O_CREAT        _O_CREAT
-#define UV_FS_O_EXCL         _O_EXCL
-#define UV_FS_O_RANDOM       _O_RANDOM
-#define UV_FS_O_RDONLY       _O_RDONLY
-#define UV_FS_O_RDWR         _O_RDWR
-#define UV_FS_O_SEQUENTIAL   _O_SEQUENTIAL
-#define UV_FS_O_SHORT_LIVED  _O_SHORT_LIVED
-#define UV_FS_O_TEMPORARY    _O_TEMPORARY
-#define UV_FS_O_TRUNC        _O_TRUNC
-#define UV_FS_O_WRONLY       _O_WRONLY
-
-/* fs open() flags supported on other platforms (or mapped on this platform): */
-#define UV_FS_O_DIRECT       0x02000000 /* FILE_FLAG_NO_BUFFERING */
-#define UV_FS_O_DIRECTORY    0
-#define UV_FS_O_DSYNC        0x04000000 /* FILE_FLAG_WRITE_THROUGH */
-#define UV_FS_O_EXLOCK       0x10000000 /* EXCLUSIVE SHARING MODE */
-#define UV_FS_O_NOATIME      0
-#define UV_FS_O_NOCTTY       0
-#define UV_FS_O_NOFOLLOW     0
-#define UV_FS_O_NONBLOCK     0
-#define UV_FS_O_SYMLINK      0
-#define UV_FS_O_SYNC         0x08000000 /* FILE_FLAG_WRITE_THROUGH */
diff --git a/wpiutil/src/main/native/libuv/src/fs-poll.cpp b/wpiutil/src/main/native/libuv/src/fs-poll.cpp
deleted file mode 100644
index 14d64de..0000000
--- a/wpiutil/src/main/native/libuv/src/fs-poll.cpp
+++ /dev/null
@@ -1,288 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "uv-common.h"
-
-#ifdef _WIN32
-#include "win/internal.h"
-#include "win/handle-inl.h"
-#define uv__make_close_pending(h) uv_want_endgame((h)->loop, (h))
-#else
-#include "unix/internal.h"
-#endif
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-struct poll_ctx {
-  uv_fs_poll_t* parent_handle;
-  int busy_polling;
-  unsigned int interval;
-  uint64_t start_time;
-  uv_loop_t* loop;
-  uv_fs_poll_cb poll_cb;
-  uv_timer_t timer_handle;
-  uv_fs_t fs_req; /* TODO(bnoordhuis) mark fs_req internal */
-  uv_stat_t statbuf;
-  struct poll_ctx* previous; /* context from previous start()..stop() period */
-  char path[1]; /* variable length */
-};
-
-static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b);
-static void poll_cb(uv_fs_t* req);
-static void timer_cb(uv_timer_t* timer);
-static void timer_close_cb(uv_handle_t* handle);
-
-static uv_stat_t zero_statbuf;
-
-
-int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
-  handle->poll_ctx = NULL;
-  return 0;
-}
-
-
-int uv_fs_poll_start(uv_fs_poll_t* handle,
-                     uv_fs_poll_cb cb,
-                     const char* path,
-                     unsigned int interval) {
-  struct poll_ctx* ctx;
-  uv_loop_t* loop;
-  size_t len;
-  int err;
-
-  if (uv_is_active((uv_handle_t*)handle))
-    return 0;
-
-  loop = handle->loop;
-  len = strlen(path);
-  ctx = (struct poll_ctx*)uv__calloc(1, sizeof(*ctx) + len);
-
-  if (ctx == NULL)
-    return UV_ENOMEM;
-
-  ctx->loop = loop;
-  ctx->poll_cb = cb;
-  ctx->interval = interval ? interval : 1;
-  ctx->start_time = uv_now(loop);
-  ctx->parent_handle = handle;
-  memcpy(ctx->path, path, len + 1);
-
-  err = uv_timer_init(loop, &ctx->timer_handle);
-  if (err < 0)
-    goto error;
-
-  ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
-  uv__handle_unref(&ctx->timer_handle);
-
-  err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
-  if (err < 0)
-    goto error;
-
-  if (handle->poll_ctx != NULL)
-    ctx->previous = (struct poll_ctx*)handle->poll_ctx;
-  handle->poll_ctx = ctx;
-  uv__handle_start(handle);
-
-  return 0;
-
-error:
-  uv__free(ctx);
-  return err;
-}
-
-
-int uv_fs_poll_stop(uv_fs_poll_t* handle) {
-  struct poll_ctx* ctx;
-
-  if (!uv_is_active((uv_handle_t*)handle))
-    return 0;
-
-  ctx = (struct poll_ctx*)handle->poll_ctx;
-  assert(ctx != NULL);
-  assert(ctx->parent_handle == handle);
-
-  /* Close the timer if it's active. If it's inactive, there's a stat request
-   * in progress and poll_cb will take care of the cleanup.
-   */
-  if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
-    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
-
-  uv__handle_stop(handle);
-
-  return 0;
-}
-
-
-int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
-  struct poll_ctx* ctx;
-  size_t required_len;
-
-  if (!uv_is_active((uv_handle_t*)handle)) {
-    *size = 0;
-    return UV_EINVAL;
-  }
-
-  ctx = (struct poll_ctx*)handle->poll_ctx;
-  assert(ctx != NULL);
-
-  required_len = strlen(ctx->path);
-  if (required_len >= *size) {
-    *size = required_len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, ctx->path, required_len);
-  *size = required_len;
-  buffer[required_len] = '\0';
-
-  return 0;
-}
-
-
-void uv__fs_poll_close(uv_fs_poll_t* handle) {
-  uv_fs_poll_stop(handle);
-
-  if (handle->poll_ctx == NULL)
-    uv__make_close_pending((uv_handle_t*)handle);
-}
-
-
-static void timer_cb(uv_timer_t* timer) {
-  struct poll_ctx* ctx;
-
-  ctx = container_of(timer, struct poll_ctx, timer_handle);
-  assert(ctx->parent_handle != NULL);
-  assert(ctx->parent_handle->poll_ctx == ctx);
-  ctx->start_time = uv_now(ctx->loop);
-
-  if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
-    abort();
-}
-
-
-static void poll_cb(uv_fs_t* req) {
-  uv_stat_t* statbuf;
-  struct poll_ctx* ctx;
-  uint64_t interval;
-  uv_fs_poll_t* handle;
-
-  ctx = container_of(req, struct poll_ctx, fs_req);
-  handle = ctx->parent_handle;
-
-  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
-    goto out;
-
-  if (req->result != 0) {
-    if (ctx->busy_polling != req->result) {
-      ctx->poll_cb(ctx->parent_handle,
-                   req->result,
-                   &ctx->statbuf,
-                   &zero_statbuf);
-      ctx->busy_polling = req->result;
-    }
-    goto out;
-  }
-
-  statbuf = &req->statbuf;
-
-  if (ctx->busy_polling != 0)
-    if (ctx->busy_polling < 0 || !statbuf_eq(&ctx->statbuf, statbuf))
-      ctx->poll_cb(ctx->parent_handle, 0, &ctx->statbuf, statbuf);
-
-  ctx->statbuf = *statbuf;
-  ctx->busy_polling = 1;
-
-out:
-  uv_fs_req_cleanup(req);
-
-  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {
-    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
-    return;
-  }
-
-  /* Reschedule timer, subtract the delay from doing the stat(). */
-  interval = ctx->interval;
-  interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;
-
-  if (uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0))
-    abort();
-}
-
-
-static void timer_close_cb(uv_handle_t* timer) {
-  struct poll_ctx* ctx;
-  struct poll_ctx* it;
-  struct poll_ctx* last;
-  uv_fs_poll_t* handle;
-
-  ctx = container_of(timer, struct poll_ctx, timer_handle);
-  handle = ctx->parent_handle;
-  if (ctx == handle->poll_ctx) {
-    handle->poll_ctx = ctx->previous;
-    if (handle->poll_ctx == NULL && uv__is_closing(handle))
-      uv__make_close_pending((uv_handle_t*)handle);
-  } else {
-    for (last = (struct poll_ctx*)handle->poll_ctx, it = last->previous;
-         it != ctx;
-         last = it, it = it->previous) {
-      assert(last->previous != NULL);
-    }
-    last->previous = ctx->previous;
-  }
-  uv__free(ctx);
-}
-
-
-static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
-  return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec
-      && a->st_mtim.tv_nsec == b->st_mtim.tv_nsec
-      && a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec
-      && a->st_ctim.tv_sec == b->st_ctim.tv_sec
-      && a->st_mtim.tv_sec == b->st_mtim.tv_sec
-      && a->st_birthtim.tv_sec == b->st_birthtim.tv_sec
-      && a->st_size == b->st_size
-      && a->st_mode == b->st_mode
-      && a->st_uid == b->st_uid
-      && a->st_gid == b->st_gid
-      && a->st_ino == b->st_ino
-      && a->st_dev == b->st_dev
-      && a->st_flags == b->st_flags
-      && a->st_gen == b->st_gen;
-}
-
-
-#if defined(_WIN32)
-
-#include "win/internal.h"
-#include "win/handle-inl.h"
-
-void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-  uv__handle_close(handle);
-}
-
-#endif /* _WIN32 */
diff --git a/wpiutil/src/main/native/libuv/src/heap-inl.h b/wpiutil/src/main/native/libuv/src/heap-inl.h
deleted file mode 100644
index 1e2ed60..0000000
--- a/wpiutil/src/main/native/libuv/src/heap-inl.h
+++ /dev/null
@@ -1,245 +0,0 @@
-/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef UV_SRC_HEAP_H_
-#define UV_SRC_HEAP_H_
-
-#include <stddef.h>  /* NULL */
-
-#if defined(__GNUC__)
-# define HEAP_EXPORT(declaration) __attribute__((unused)) static declaration
-#else
-# define HEAP_EXPORT(declaration) static declaration
-#endif
-
-struct heap_node {
-  struct heap_node* left;
-  struct heap_node* right;
-  struct heap_node* parent;
-};
-
-/* A binary min heap.  The usual properties hold: the root is the lowest
- * element in the set, the height of the tree is at most log2(nodes) and
- * it's always a complete binary tree.
- *
- * The heap function try hard to detect corrupted tree nodes at the cost
- * of a minor reduction in performance.  Compile with -DNDEBUG to disable.
- */
-struct heap {
-  struct heap_node* min;
-  unsigned int nelts;
-};
-
-/* Return non-zero if a < b. */
-typedef int (*heap_compare_fn)(const struct heap_node* a,
-                               const struct heap_node* b);
-
-/* Public functions. */
-HEAP_EXPORT(void heap_init(struct heap* heap));
-HEAP_EXPORT(struct heap_node* heap_min(const struct heap* heap));
-HEAP_EXPORT(void heap_insert(struct heap* heap,
-                             struct heap_node* newnode,
-                             heap_compare_fn less_than));
-HEAP_EXPORT(void heap_remove(struct heap* heap,
-                             struct heap_node* node,
-                             heap_compare_fn less_than));
-HEAP_EXPORT(void heap_dequeue(struct heap* heap, heap_compare_fn less_than));
-
-/* Implementation follows. */
-
-HEAP_EXPORT(void heap_init(struct heap* heap)) {
-  heap->min = NULL;
-  heap->nelts = 0;
-}
-
-HEAP_EXPORT(struct heap_node* heap_min(const struct heap* heap)) {
-  return heap->min;
-}
-
-/* Swap parent with child. Child moves closer to the root, parent moves away. */
-static void heap_node_swap(struct heap* heap,
-                           struct heap_node* parent,
-                           struct heap_node* child) {
-  struct heap_node* sibling;
-  struct heap_node t;
-
-  t = *parent;
-  *parent = *child;
-  *child = t;
-
-  parent->parent = child;
-  if (child->left == child) {
-    child->left = parent;
-    sibling = child->right;
-  } else {
-    child->right = parent;
-    sibling = child->left;
-  }
-  if (sibling != NULL)
-    sibling->parent = child;
-
-  if (parent->left != NULL)
-    parent->left->parent = parent;
-  if (parent->right != NULL)
-    parent->right->parent = parent;
-
-  if (child->parent == NULL)
-    heap->min = child;
-  else if (child->parent->left == parent)
-    child->parent->left = child;
-  else
-    child->parent->right = child;
-}
-
-HEAP_EXPORT(void heap_insert(struct heap* heap,
-                             struct heap_node* newnode,
-                             heap_compare_fn less_than)) {
-  struct heap_node** parent;
-  struct heap_node** child;
-  unsigned int path;
-  unsigned int n;
-  unsigned int k;
-
-  newnode->left = NULL;
-  newnode->right = NULL;
-  newnode->parent = NULL;
-
-  /* Calculate the path from the root to the insertion point.  This is a min
-   * heap so we always insert at the left-most free node of the bottom row.
-   */
-  path = 0;
-  for (k = 0, n = 1 + heap->nelts; n >= 2; k += 1, n /= 2)
-    path = (path << 1) | (n & 1);
-
-  /* Now traverse the heap using the path we calculated in the previous step. */
-  parent = child = &heap->min;
-  while (k > 0) {
-    parent = child;
-    if (path & 1)
-      child = &(*child)->right;
-    else
-      child = &(*child)->left;
-    path >>= 1;
-    k -= 1;
-  }
-
-  /* Insert the new node. */
-  newnode->parent = *parent;
-  *child = newnode;
-  heap->nelts += 1;
-
-  /* Walk up the tree and check at each node if the heap property holds.
-   * It's a min heap so parent < child must be true.
-   */
-  while (newnode->parent != NULL && less_than(newnode, newnode->parent))
-    heap_node_swap(heap, newnode->parent, newnode);
-}
-
-HEAP_EXPORT(void heap_remove(struct heap* heap,
-                             struct heap_node* node,
-                             heap_compare_fn less_than)) {
-  struct heap_node* smallest;
-  struct heap_node** max;
-  struct heap_node* child;
-  unsigned int path;
-  unsigned int k;
-  unsigned int n;
-
-  if (heap->nelts == 0)
-    return;
-
-  /* Calculate the path from the min (the root) to the max, the left-most node
-   * of the bottom row.
-   */
-  path = 0;
-  for (k = 0, n = heap->nelts; n >= 2; k += 1, n /= 2)
-    path = (path << 1) | (n & 1);
-
-  /* Now traverse the heap using the path we calculated in the previous step. */
-  max = &heap->min;
-  while (k > 0) {
-    if (path & 1)
-      max = &(*max)->right;
-    else
-      max = &(*max)->left;
-    path >>= 1;
-    k -= 1;
-  }
-
-  heap->nelts -= 1;
-
-  /* Unlink the max node. */
-  child = *max;
-  *max = NULL;
-
-  if (child == node) {
-    /* We're removing either the max or the last node in the tree. */
-    if (child == heap->min) {
-      heap->min = NULL;
-    }
-    return;
-  }
-
-  /* Replace the to be deleted node with the max node. */
-  child->left = node->left;
-  child->right = node->right;
-  child->parent = node->parent;
-
-  if (child->left != NULL) {
-    child->left->parent = child;
-  }
-
-  if (child->right != NULL) {
-    child->right->parent = child;
-  }
-
-  if (node->parent == NULL) {
-    heap->min = child;
-  } else if (node->parent->left == node) {
-    node->parent->left = child;
-  } else {
-    node->parent->right = child;
-  }
-
-  /* Walk down the subtree and check at each node if the heap property holds.
-   * It's a min heap so parent < child must be true.  If the parent is bigger,
-   * swap it with the smallest child.
-   */
-  for (;;) {
-    smallest = child;
-    if (child->left != NULL && less_than(child->left, smallest))
-      smallest = child->left;
-    if (child->right != NULL && less_than(child->right, smallest))
-      smallest = child->right;
-    if (smallest == child)
-      break;
-    heap_node_swap(heap, child, smallest);
-  }
-
-  /* Walk up the subtree and check that each parent is less than the node
-   * this is required, because `max` node is not guaranteed to be the
-   * actual maximum in tree
-   */
-  while (child->parent != NULL && less_than(child, child->parent))
-    heap_node_swap(heap, child->parent, child);
-}
-
-HEAP_EXPORT(void heap_dequeue(struct heap* heap, heap_compare_fn less_than)) {
-  heap_remove(heap, heap->min, less_than);
-}
-
-#undef HEAP_EXPORT
-
-#endif  /* UV_SRC_HEAP_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/idna.cpp b/wpiutil/src/main/native/libuv/src/idna.cpp
deleted file mode 100644
index 6b2406c..0000000
--- a/wpiutil/src/main/native/libuv/src/idna.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-/* Copyright (c) 2011, 2018 Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-/* Derived from https://github.com/bnoordhuis/punycode
- * but updated to support IDNA 2008.
- */
-
-#include "uv.h"
-#include "idna.h"
-#include <string.h>
-
-static unsigned uv__utf8_decode1_slow(const char** p,
-                                      const char* pe,
-                                      unsigned a) {
-  unsigned b;
-  unsigned c;
-  unsigned d;
-  unsigned min;
-
-  if (a > 0xF7)
-    return -1;
-
-  switch (*p - pe) {
-  default:
-    if (a > 0xEF) {
-      min = 0x10000;
-      a = a & 7;
-      b = (unsigned char) *(*p)++;
-      c = (unsigned char) *(*p)++;
-      d = (unsigned char) *(*p)++;
-      break;
-    }
-    /* Fall through. */
-  case 2:
-    if (a > 0xDF) {
-      min = 0x800;
-      b = 0x80 | (a & 15);
-      c = (unsigned char) *(*p)++;
-      d = (unsigned char) *(*p)++;
-      a = 0;
-      break;
-    }
-    /* Fall through. */
-  case 1:
-    if (a > 0xBF) {
-      min = 0x80;
-      b = 0x80;
-      c = 0x80 | (a & 31);
-      d = (unsigned char) *(*p)++;
-      a = 0;
-      break;
-    }
-    return -1;  /* Invalid continuation byte. */
-  }
-
-  if (0x80 != (0xC0 & (b ^ c ^ d)))
-    return -1;  /* Invalid sequence. */
-
-  b &= 63;
-  c &= 63;
-  d &= 63;
-  a = (a << 18) | (b << 12) | (c << 6) | d;
-
-  if (a < min)
-    return -1;  /* Overlong sequence. */
-
-  if (a > 0x10FFFF)
-    return -1;  /* Four-byte sequence > U+10FFFF. */
-
-  if (a >= 0xD800 && a <= 0xDFFF)
-    return -1;  /* Surrogate pair. */
-
-  return a;
-}
-
-unsigned uv__utf8_decode1(const char** p, const char* pe) {
-  unsigned a;
-
-  a = (unsigned char) *(*p)++;
-
-  if (a < 128)
-    return a;  /* ASCII, common case. */
-
-  return uv__utf8_decode1_slow(p, pe, a);
-}
-
-#define foreach_codepoint(c, p, pe) \
-  for (; (void) (*p <= pe && (c = uv__utf8_decode1(p, pe))), *p <= pe;)
-
-static int uv__idna_toascii_label(const char* s, const char* se,
-                                  char** d, char* de) {
-  static const char alphabet[] = "abcdefghijklmnopqrstuvwxyz0123456789";
-  const char* ss;
-  unsigned c = 0;
-  unsigned h;
-  unsigned k;
-  unsigned n;
-  unsigned m;
-  unsigned q;
-  unsigned t;
-  unsigned x;
-  unsigned y;
-  unsigned bias;
-  unsigned delta;
-  unsigned todo;
-  int first;
-
-  h = 0;
-  ss = s;
-  todo = 0;
-
-  foreach_codepoint(c, &s, se) {
-    if (c < 128)
-      h++;
-    else if (c == (unsigned) -1)
-      return UV_EINVAL;
-    else
-      todo++;
-  }
-
-  if (todo > 0) {
-    if (*d < de) *(*d)++ = 'x';
-    if (*d < de) *(*d)++ = 'n';
-    if (*d < de) *(*d)++ = '-';
-    if (*d < de) *(*d)++ = '-';
-  }
-
-  x = 0;
-  s = ss;
-  foreach_codepoint(c, &s, se) {
-    if (c > 127)
-      continue;
-
-    if (*d < de)
-      *(*d)++ = c;
-
-    if (++x == h)
-      break;  /* Visited all ASCII characters. */
-  }
-
-  if (todo == 0)
-    return h;
-
-  /* Only write separator when we've written ASCII characters first. */
-  if (h > 0)
-    if (*d < de)
-      *(*d)++ = '-';
-
-  n = 128;
-  bias = 72;
-  delta = 0;
-  first = 1;
-
-  while (todo > 0) {
-    m = -1;
-    s = ss;
-    foreach_codepoint(c, &s, se)
-      if (c >= n)
-        if (c < m)
-          m = c;
-
-    x = m - n;
-    y = h + 1;
-
-    if (x > ~delta / y)
-      return UV_E2BIG;  /* Overflow. */
-
-    delta += x * y;
-    n = m;
-
-    s = ss;
-    foreach_codepoint(c, &s, se) {
-      if (c < n)
-        if (++delta == 0)
-          return UV_E2BIG;  /* Overflow. */
-
-      if (c != n)
-        continue;
-
-      for (k = 36, q = delta; /* empty */; k += 36) {
-        t = 1;
-
-        if (k > bias)
-          t = k - bias;
-
-        if (t > 26)
-          t = 26;
-
-        if (q < t)
-          break;
-
-        /* TODO(bnoordhuis) Since 1 <= t <= 26 and therefore
-         * 10 <= y <= 35, we can optimize the long division
-         * into a table-based reciprocal multiplication.
-         */
-        x = q - t;
-        y = 36 - t;  /* 10 <= y <= 35 since 1 <= t <= 26. */
-        q = x / y;
-        t = t + x % y;  /* 1 <= t <= 35 because of y. */
-
-        if (*d < de)
-          *(*d)++ = alphabet[t];
-      }
-
-      if (*d < de)
-        *(*d)++ = alphabet[q];
-
-      delta /= 2;
-
-      if (first) {
-        delta /= 350;
-        first = 0;
-      }
-
-      /* No overflow check is needed because |delta| was just
-       * divided by 2 and |delta+delta >= delta + delta/h|.
-       */
-      h++;
-      delta += delta / h;
-
-      for (bias = 0; delta > 35 * 26 / 2; bias += 36)
-        delta /= 35;
-
-      bias += 36 * delta / (delta + 38);
-      delta = 0;
-      todo--;
-    }
-
-    delta++;
-    n++;
-  }
-
-  return 0;
-}
-
-#undef foreach_codepoint
-
-long uv__idna_toascii(const char* s, const char* se, char* d, char* de) {
-  const char* si;
-  const char* st;
-  unsigned c;
-  char* ds;
-  int rc;
-
-  ds = d;
-
-  for (si = s; si < se; /* empty */) {
-    st = si;
-    c = uv__utf8_decode1(&si, se);
-
-    if (c != '.')
-      if (c != 0x3002)  /* 。 */
-        if (c != 0xFF0E)  /* ． */
-          if (c != 0xFF61)  /* ｡ */
-            continue;
-
-    rc = uv__idna_toascii_label(s, st, &d, de);
-
-    if (rc < 0)
-      return rc;
-
-    if (d < de)
-      *d++ = '.';
-
-    s = si;
-  }
-
-  if (s < se) {
-    rc = uv__idna_toascii_label(s, se, &d, de);
-
-    if (rc < 0)
-      return rc;
-  }
-
-  if (d < de)
-    *d++ = '\0';
-
-  return d - ds;  /* Number of bytes written. */
-}
diff --git a/wpiutil/src/main/native/libuv/src/idna.h b/wpiutil/src/main/native/libuv/src/idna.h
deleted file mode 100644
index 8e0c592..0000000
--- a/wpiutil/src/main/native/libuv/src/idna.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Copyright (c) 2011, 2018 Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef UV_SRC_IDNA_H_
-#define UV_SRC_IDNA_H_
-
-/* Decode a single codepoint. Returns the codepoint or UINT32_MAX on error.
- * |p| is updated on success _and_ error, i.e., bad multi-byte sequences are
- * skipped in their entirety, not just the first bad byte.
- */
-unsigned uv__utf8_decode1(const char** p, const char* pe);
-
-/* Convert a UTF-8 domain name to IDNA 2008 / Punycode. A return value >= 0
- * is the number of bytes written to |d|, including the trailing nul byte.
- * A return value < 0 is a libuv error code. |s| and |d| can not overlap.
- */
-long uv__idna_toascii(const char* s, const char* se, char* d, char* de);
-
-#endif  /* UV_SRC_IDNA_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/inet.cpp b/wpiutil/src/main/native/libuv/src/inet.cpp
deleted file mode 100644
index 167ec11..0000000
--- a/wpiutil/src/main/native/libuv/src/inet.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
- * Copyright (c) 1996-1999 by Internet Software Consortium.
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
- * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <stdio.h>
-#include <string.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1600
-# include "uv/stdint-msvc2008.h"
-#else
-# include <stdint.h>
-#endif
-
-#include "uv.h"
-#include "uv-common.h"
-
-#ifdef _WIN32
-#pragma warning(disable : 6001)
-#endif
-
-#define UV__INET_ADDRSTRLEN         16
-#define UV__INET6_ADDRSTRLEN        46
-
-
-static int inet_ntop4(const unsigned char *src, char *dst, size_t size);
-static int inet_ntop6(const unsigned char *src, char *dst, size_t size);
-static int inet_pton4(const char *src, unsigned char *dst);
-static int inet_pton6(const char *src, unsigned char *dst);
-
-
-int uv_inet_ntop(int af, const void* src, char* dst, size_t size) {
-  switch (af) {
-  case AF_INET:
-    return (inet_ntop4((const unsigned char*)src, dst, size));
-  case AF_INET6:
-    return (inet_ntop6((const unsigned char*)src, dst, size));
-  default:
-    return UV_EAFNOSUPPORT;
-  }
-  /* NOTREACHED */
-}
-
-
-static int inet_ntop4(const unsigned char *src, char *dst, size_t size) {
-  static const char fmt[] = "%u.%u.%u.%u";
-  char tmp[UV__INET_ADDRSTRLEN];
-  int l;
-
-  l = snprintf(tmp, sizeof(tmp), fmt, src[0], src[1], src[2], src[3]);
-  if (l <= 0 || (size_t) l >= size) {
-    return UV_ENOSPC;
-  }
-  uv__strscpy(dst, tmp, size);
-  return 0;
-}
-
-
-static int inet_ntop6(const unsigned char *src, char *dst, size_t size) {
-  /*
-   * Note that int32_t and int16_t need only be "at least" large enough
-   * to contain a value of the specified size.  On some systems, like
-   * Crays, there is no such thing as an integer variable with 16 bits.
-   * Keep this in mind if you think this function should have been coded
-   * to use pointer overlays.  All the world's not a VAX.
-   */
-  char tmp[UV__INET6_ADDRSTRLEN], *tp;
-  struct { int base, len; } best, cur;
-  unsigned int words[sizeof(struct in6_addr) / sizeof(uint16_t)];
-  int i;
-
-  /*
-   * Preprocess:
-   *  Copy the input (bytewise) array into a wordwise array.
-   *  Find the longest run of 0x00's in src[] for :: shorthanding.
-   */
-  memset(words, '\0', sizeof words);
-  for (i = 0; i < (int) sizeof(struct in6_addr); i++)
-    words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
-  best.base = -1;
-  best.len = 0;
-  cur.base = -1;
-  cur.len = 0;
-  for (i = 0; i < (int) ARRAY_SIZE(words); i++) {
-    if (words[i] == 0) {
-      if (cur.base == -1)
-        cur.base = i, cur.len = 1;
-      else
-        cur.len++;
-    } else {
-      if (cur.base != -1) {
-        if (best.base == -1 || cur.len > best.len)
-          best = cur;
-        cur.base = -1;
-      }
-    }
-  }
-  if (cur.base != -1) {
-    if (best.base == -1 || cur.len > best.len)
-      best = cur;
-  }
-  if (best.base != -1 && best.len < 2)
-    best.base = -1;
-
-  /*
-   * Format the result.
-   */
-  tp = tmp;
-  for (i = 0; i < (int) ARRAY_SIZE(words); i++) {
-    /* Are we inside the best run of 0x00's? */
-    if (best.base != -1 && i >= best.base &&
-        i < (best.base + best.len)) {
-      if (i == best.base)
-        *tp++ = ':';
-      continue;
-    }
-    /* Are we following an initial run of 0x00s or any real hex? */
-    if (i != 0)
-      *tp++ = ':';
-    /* Is this address an encapsulated IPv4? */
-    if (i == 6 && best.base == 0 && (best.len == 6 ||
-        (best.len == 7 && words[7] != 0x0001) ||
-        (best.len == 5 && words[5] == 0xffff))) {
-      int err = inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp));
-      if (err)
-        return err;
-      tp += strlen(tp);
-      break;
-    }
-    tp += sprintf(tp, "%x", words[i]);
-  }
-  /* Was it a trailing run of 0x00's? */
-  if (best.base != -1 && (best.base + best.len) == ARRAY_SIZE(words))
-    *tp++ = ':';
-  *tp++ = '\0';
-  if (UV_E2BIG == uv__strscpy(dst, tmp, size))
-    return UV_ENOSPC;
-  return 0;
-}
-
-
-int uv_inet_pton(int af, const char* src, void* dst) {
-  if (src == NULL || dst == NULL)
-    return UV_EINVAL;
-
-  switch (af) {
-  case AF_INET:
-    return (inet_pton4(src, (unsigned char*)dst));
-  case AF_INET6: {
-    int len;
-    char tmp[UV__INET6_ADDRSTRLEN], *s;
-    const char *p;
-    s = (char*) src;
-    p = strchr(src, '%');
-    if (p != NULL) {
-      s = tmp;
-      len = p - src;
-      if (len > UV__INET6_ADDRSTRLEN-1)
-        return UV_EINVAL;
-      memcpy(s, src, len);
-      s[len] = '\0';
-    }
-    return inet_pton6(s, (unsigned char*)dst);
-  }
-  default:
-    return UV_EAFNOSUPPORT;
-  }
-  /* NOTREACHED */
-}
-
-
-static int inet_pton4(const char *src, unsigned char *dst) {
-  static const char digits[] = "0123456789";
-  int saw_digit, octets, ch;
-  unsigned char tmp[sizeof(struct in_addr)], *tp;
-
-  saw_digit = 0;
-  octets = 0;
-  *(tp = tmp) = 0;
-  while ((ch = *src++) != '\0') {
-    const char *pch;
-
-    if ((pch = strchr(digits, ch)) != NULL) {
-      unsigned int nw = *tp * 10 + (pch - digits);
-
-      if (saw_digit && *tp == 0)
-        return UV_EINVAL;
-      if (nw > 255)
-        return UV_EINVAL;
-      *tp = nw;
-      if (!saw_digit) {
-        if (++octets > 4)
-          return UV_EINVAL;
-        saw_digit = 1;
-      }
-    } else if (ch == '.' && saw_digit) {
-      if (octets == 4)
-        return UV_EINVAL;
-      *++tp = 0;
-      saw_digit = 0;
-    } else
-      return UV_EINVAL;
-  }
-  if (octets < 4)
-    return UV_EINVAL;
-  memcpy(dst, tmp, sizeof(struct in_addr));
-  return 0;
-}
-
-
-static int inet_pton6(const char *src, unsigned char *dst) {
-  static const char xdigits_l[] = "0123456789abcdef",
-                    xdigits_u[] = "0123456789ABCDEF";
-  unsigned char tmp[sizeof(struct in6_addr)], *tp, *endp, *colonp;
-  const char *xdigits, *curtok;
-  int ch, seen_xdigits;
-  unsigned int val;
-
-  memset((tp = tmp), '\0', sizeof tmp);
-  endp = tp + sizeof tmp;
-  colonp = NULL;
-  /* Leading :: requires some special handling. */
-  if (*src == ':')
-    if (*++src != ':')
-      return UV_EINVAL;
-  curtok = src;
-  seen_xdigits = 0;
-  val = 0;
-  while ((ch = *src++) != '\0') {
-    const char *pch;
-
-    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
-      pch = strchr((xdigits = xdigits_u), ch);
-    if (pch != NULL) {
-      val <<= 4;
-      val |= (pch - xdigits);
-      if (++seen_xdigits > 4)
-        return UV_EINVAL;
-      continue;
-    }
-    if (ch == ':') {
-      curtok = src;
-      if (!seen_xdigits) {
-        if (colonp)
-          return UV_EINVAL;
-        colonp = tp;
-        continue;
-      } else if (*src == '\0') {
-        return UV_EINVAL;
-      }
-      if (tp + sizeof(uint16_t) > endp)
-        return UV_EINVAL;
-      *tp++ = (unsigned char) (val >> 8) & 0xff;
-      *tp++ = (unsigned char) val & 0xff;
-      seen_xdigits = 0;
-      val = 0;
-      continue;
-    }
-    if (ch == '.' && ((tp + sizeof(struct in_addr)) <= endp)) {
-      int err = inet_pton4(curtok, tp);
-      if (err == 0) {
-        tp += sizeof(struct in_addr);
-        seen_xdigits = 0;
-        break;  /*%< '\\0' was seen by inet_pton4(). */
-      }
-    }
-    return UV_EINVAL;
-  }
-  if (seen_xdigits) {
-    if (tp + sizeof(uint16_t) > endp)
-      return UV_EINVAL;
-    *tp++ = (unsigned char) (val >> 8) & 0xff;
-    *tp++ = (unsigned char) val & 0xff;
-  }
-  if (colonp != NULL) {
-    /*
-     * Since some memmove()'s erroneously fail to handle
-     * overlapping regions, we'll do the shift by hand.
-     */
-    const int n = tp - colonp;
-    int i;
-
-    if (tp == endp)
-      return UV_EINVAL;
-    for (i = 1; i <= n; i++) {
-      endp[- i] = colonp[n - i];
-      colonp[n - i] = 0;
-    }
-    tp = endp;
-  }
-  if (tp != endp)
-    return UV_EINVAL;
-  memcpy(dst, tmp, sizeof tmp);
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/queue.h b/wpiutil/src/main/native/libuv/src/queue.h
deleted file mode 100644
index ff3540a..0000000
--- a/wpiutil/src/main/native/libuv/src/queue.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef QUEUE_H_
-#define QUEUE_H_
-
-#include <stddef.h>
-
-typedef void *QUEUE[2];
-
-/* Private macros. */
-#define QUEUE_NEXT(q)       (*(QUEUE **) &((*(q))[0]))
-#define QUEUE_PREV(q)       (*(QUEUE **) &((*(q))[1]))
-#define QUEUE_PREV_NEXT(q)  (QUEUE_NEXT(QUEUE_PREV(q)))
-#define QUEUE_NEXT_PREV(q)  (QUEUE_PREV(QUEUE_NEXT(q)))
-
-/* Public macros. */
-#define QUEUE_DATA(ptr, type, field)                                          \
-  ((type *) ((char *) (ptr) - offsetof(type, field)))
-
-/* Important note: mutating the list while QUEUE_FOREACH is
- * iterating over its elements results in undefined behavior.
- */
-#define QUEUE_FOREACH(q, h)                                                   \
-  for ((q) = QUEUE_NEXT(h); (q) != (h); (q) = QUEUE_NEXT(q))
-
-#define QUEUE_EMPTY(q)                                                        \
-  ((const QUEUE *) (q) == (const QUEUE *) QUEUE_NEXT(q))
-
-#define QUEUE_HEAD(q)                                                         \
-  (QUEUE_NEXT(q))
-
-#define QUEUE_INIT(q)                                                         \
-  do {                                                                        \
-    QUEUE_NEXT(q) = (q);                                                      \
-    QUEUE_PREV(q) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_ADD(h, n)                                                       \
-  do {                                                                        \
-    QUEUE_PREV_NEXT(h) = QUEUE_NEXT(n);                                       \
-    QUEUE_NEXT_PREV(n) = QUEUE_PREV(h);                                       \
-    QUEUE_PREV(h) = QUEUE_PREV(n);                                            \
-    QUEUE_PREV_NEXT(h) = (h);                                                 \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_SPLIT(h, q, n)                                                  \
-  do {                                                                        \
-    QUEUE_PREV(n) = QUEUE_PREV(h);                                            \
-    QUEUE_PREV_NEXT(n) = (n);                                                 \
-    QUEUE_NEXT(n) = (q);                                                      \
-    QUEUE_PREV(h) = QUEUE_PREV(q);                                            \
-    QUEUE_PREV_NEXT(h) = (h);                                                 \
-    QUEUE_PREV(q) = (n);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_MOVE(h, n)                                                      \
-  do {                                                                        \
-    if (QUEUE_EMPTY(h))                                                       \
-      QUEUE_INIT(n);                                                          \
-    else {                                                                    \
-      QUEUE* q = QUEUE_HEAD(h);                                               \
-      QUEUE_SPLIT(h, q, n);                                                   \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_INSERT_HEAD(h, q)                                               \
-  do {                                                                        \
-    QUEUE_NEXT(q) = QUEUE_NEXT(h);                                            \
-    QUEUE_PREV(q) = (h);                                                      \
-    QUEUE_NEXT_PREV(q) = (q);                                                 \
-    QUEUE_NEXT(h) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_INSERT_TAIL(h, q)                                               \
-  do {                                                                        \
-    QUEUE_NEXT(q) = (h);                                                      \
-    QUEUE_PREV(q) = QUEUE_PREV(h);                                            \
-    QUEUE_PREV_NEXT(q) = (q);                                                 \
-    QUEUE_PREV(h) = (q);                                                      \
-  }                                                                           \
-  while (0)
-
-#define QUEUE_REMOVE(q)                                                       \
-  do {                                                                        \
-    QUEUE_PREV_NEXT(q) = QUEUE_NEXT(q);                                       \
-    QUEUE_NEXT_PREV(q) = QUEUE_PREV(q);                                       \
-  }                                                                           \
-  while (0)
-
-#endif /* QUEUE_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/strscpy.cpp b/wpiutil/src/main/native/libuv/src/strscpy.cpp
deleted file mode 100644
index 4a9e863..0000000
--- a/wpiutil/src/main/native/libuv/src/strscpy.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "strscpy.h"
-#include <limits.h>  /* SSIZE_MAX */
-
-ssize_t uv__strscpy(char* d, const char* s, size_t n) {
-  size_t i;
-
-  for (i = 0; i < n; i++)
-    if ('\0' == (d[i] = s[i]))
-      return i > SSIZE_MAX ? (ssize_t) UV_E2BIG : (ssize_t) i;
-
-  if (i == 0)
-    return 0;
-
-  d[--i] = '\0';
-
-  return UV_E2BIG;
-}
diff --git a/wpiutil/src/main/native/libuv/src/strscpy.h b/wpiutil/src/main/native/libuv/src/strscpy.h
deleted file mode 100644
index fbe0a39..0000000
--- a/wpiutil/src/main/native/libuv/src/strscpy.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef UV_STRSCPY_H_
-#define UV_STRSCPY_H_
-
-/* Include uv.h for its definitions of size_t and ssize_t.
- * size_t can be obtained directly from <stddef.h> but ssize_t requires
- * some hoop jumping on Windows that I didn't want to duplicate here.
- */
-#include "uv.h"
-
-/* Copies up to |n-1| bytes from |d| to |s| and always zero-terminates
- * the result, except when |n==0|. Returns the number of bytes copied
- * or UV_E2BIG if |d| is too small.
- *
- * See https://www.kernel.org/doc/htmldocs/kernel-api/API-strscpy.html
- */
-ssize_t uv__strscpy(char* d, const char* s, size_t n);
-
-#endif  /* UV_STRSCPY_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/threadpool.cpp b/wpiutil/src/main/native/libuv/src/threadpool.cpp
deleted file mode 100644
index 515bf40..0000000
--- a/wpiutil/src/main/native/libuv/src/threadpool.cpp
+++ /dev/null
@@ -1,388 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv-common.h"
-
-#if !defined(_WIN32)
-# include "unix/internal.h"
-#endif
-
-#include <stdlib.h>
-
-#ifdef _WIN32
-#pragma warning(disable: 6001 6011)
-#endif
-
-#define MAX_THREADPOOL_SIZE 1024
-
-static uv_once_t once = UV_ONCE_INIT;
-static uv_cond_t cond;
-static uv_mutex_t mutex;
-static unsigned int idle_threads;
-static unsigned int slow_io_work_running;
-static unsigned int nthreads;
-static uv_thread_t* threads;
-static uv_thread_t default_threads[4];
-static QUEUE exit_message;
-static QUEUE wq;
-static QUEUE run_slow_work_message;
-static QUEUE slow_io_pending_wq;
-
-static unsigned int slow_work_thread_threshold(void) {
-  return (nthreads + 1) / 2;
-}
-
-static void uv__cancelled(struct uv__work* w) {
-  abort();
-}
-
-
-/* To avoid deadlock with uv_cancel() it's crucial that the worker
- * never holds the global mutex and the loop-local mutex at the same time.
- */
-static void worker(void* arg) {
-  struct uv__work* w;
-  QUEUE* q;
-  int is_slow_work;
-
-  uv_sem_post((uv_sem_t*) arg);
-  arg = NULL;
-
-  uv_mutex_lock(&mutex);
-  for (;;) {
-    /* `mutex` should always be locked at this point. */
-
-    /* Keep waiting while either no work is present or only slow I/O
-       and we're at the threshold for that. */
-    while (QUEUE_EMPTY(&wq) ||
-           (QUEUE_HEAD(&wq) == &run_slow_work_message &&
-            QUEUE_NEXT(&run_slow_work_message) == &wq &&
-            slow_io_work_running >= slow_work_thread_threshold())) {
-      idle_threads += 1;
-      uv_cond_wait(&cond, &mutex);
-      idle_threads -= 1;
-    }
-
-    q = QUEUE_HEAD(&wq);
-    if (q == &exit_message) {
-      uv_cond_signal(&cond);
-      uv_mutex_unlock(&mutex);
-      break;
-    }
-
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);  /* Signal uv_cancel() that the work req is executing. */
-
-    is_slow_work = 0;
-    if (q == &run_slow_work_message) {
-      /* If we're at the slow I/O threshold, re-schedule until after all
-         other work in the queue is done. */
-      if (slow_io_work_running >= slow_work_thread_threshold()) {
-        QUEUE_INSERT_TAIL(&wq, q);
-        continue;
-      }
-
-      /* If we encountered a request to run slow I/O work but there is none
-         to run, that means it's cancelled => Start over. */
-      if (QUEUE_EMPTY(&slow_io_pending_wq))
-        continue;
-
-      is_slow_work = 1;
-      slow_io_work_running++;
-
-      q = QUEUE_HEAD(&slow_io_pending_wq);
-      QUEUE_REMOVE(q);
-      QUEUE_INIT(q);
-
-      /* If there is more slow I/O work, schedule it to be run as well. */
-      if (!QUEUE_EMPTY(&slow_io_pending_wq)) {
-        QUEUE_INSERT_TAIL(&wq, &run_slow_work_message);
-        if (idle_threads > 0)
-          uv_cond_signal(&cond);
-      }
-    }
-
-    uv_mutex_unlock(&mutex);
-
-    w = QUEUE_DATA(q, struct uv__work, wq);
-    w->work(w);
-
-    uv_mutex_lock(&w->loop->wq_mutex);
-    w->work = NULL;  /* Signal uv_cancel() that the work req is done
-                        executing. */
-    QUEUE_INSERT_TAIL(&w->loop->wq, &w->wq);
-    uv_async_send(&w->loop->wq_async);
-    uv_mutex_unlock(&w->loop->wq_mutex);
-
-    /* Lock `mutex` since that is expected at the start of the next
-     * iteration. */
-    uv_mutex_lock(&mutex);
-    if (is_slow_work) {
-      /* `slow_io_work_running` is protected by `mutex`. */
-      slow_io_work_running--;
-    }
-  }
-}
-
-
-static void post(QUEUE* q, enum uv__work_kind kind) {
-  uv_mutex_lock(&mutex);
-  if (kind == UV__WORK_SLOW_IO) {
-    /* Insert into a separate queue. */
-    QUEUE_INSERT_TAIL(&slow_io_pending_wq, q);
-    if (!QUEUE_EMPTY(&run_slow_work_message)) {
-      /* Running slow I/O tasks is already scheduled => Nothing to do here.
-         The worker that runs said other task will schedule this one as well. */
-      uv_mutex_unlock(&mutex);
-      return;
-    }
-    q = &run_slow_work_message;
-  }
-
-  QUEUE_INSERT_TAIL(&wq, q);
-  if (idle_threads > 0)
-    uv_cond_signal(&cond);
-  uv_mutex_unlock(&mutex);
-}
-
-
-#ifndef _WIN32
-UV_DESTRUCTOR(static void cleanup(void)) {
-  unsigned int i;
-
-  if (nthreads == 0)
-    return;
-
-  post(&exit_message, UV__WORK_CPU);
-
-  for (i = 0; i < nthreads; i++)
-    if (uv_thread_join(threads + i))
-      abort();
-
-  if (threads != default_threads)
-    uv__free(threads);
-
-  uv_mutex_destroy(&mutex);
-  uv_cond_destroy(&cond);
-
-  threads = NULL;
-  nthreads = 0;
-}
-#endif
-
-
-static void init_threads(void) {
-  unsigned int i;
-  const char* val;
-  uv_sem_t sem;
-
-  nthreads = ARRAY_SIZE(default_threads);
-  val = getenv("UV_THREADPOOL_SIZE");
-  if (val != NULL)
-    nthreads = atoi(val);
-  if (nthreads == 0)
-    nthreads = 1;
-  if (nthreads > MAX_THREADPOOL_SIZE)
-    nthreads = MAX_THREADPOOL_SIZE;
-
-  threads = default_threads;
-  if (nthreads > ARRAY_SIZE(default_threads)) {
-    threads = (uv_thread_t*)uv__malloc(nthreads * sizeof(threads[0]));
-    if (threads == NULL) {
-      nthreads = ARRAY_SIZE(default_threads);
-      threads = default_threads;
-    }
-  }
-
-  if (uv_cond_init(&cond))
-    abort();
-
-  if (uv_mutex_init(&mutex))
-    abort();
-
-  QUEUE_INIT(&wq);
-  QUEUE_INIT(&slow_io_pending_wq);
-  QUEUE_INIT(&run_slow_work_message);
-
-  if (uv_sem_init(&sem, 0))
-    abort();
-
-  for (i = 0; i < nthreads; i++)
-    if (uv_thread_create(threads + i, worker, &sem))
-      abort();
-
-  for (i = 0; i < nthreads; i++)
-    uv_sem_wait(&sem);
-
-  uv_sem_destroy(&sem);
-}
-
-
-#ifndef _WIN32
-static void reset_once(void) {
-  uv_once_t child_once = UV_ONCE_INIT;
-  memcpy(&once, &child_once, sizeof(child_once));
-}
-#endif
-
-
-static void init_once(void) {
-#ifndef _WIN32
-  /* Re-initialize the threadpool after fork.
-   * Note that this discards the global mutex and condition as well
-   * as the work queue.
-   */
-  if (pthread_atfork(NULL, NULL, &reset_once))
-    abort();
-#endif
-  init_threads();
-}
-
-
-void uv__work_submit(uv_loop_t* loop,
-                     struct uv__work* w,
-                     enum uv__work_kind kind,
-                     void (*work)(struct uv__work* w),
-                     void (*done)(struct uv__work* w, int status)) {
-  uv_once(&once, init_once);
-  w->loop = loop;
-  w->work = work;
-  w->done = done;
-  post(&w->wq, kind);
-}
-
-
-static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) {
-  int cancelled;
-
-  uv_mutex_lock(&mutex);
-  uv_mutex_lock(&w->loop->wq_mutex);
-
-  cancelled = !QUEUE_EMPTY(&w->wq) && w->work != NULL;
-  if (cancelled)
-    QUEUE_REMOVE(&w->wq);
-
-  uv_mutex_unlock(&w->loop->wq_mutex);
-  uv_mutex_unlock(&mutex);
-
-  if (!cancelled)
-    return UV_EBUSY;
-
-  w->work = uv__cancelled;
-  uv_mutex_lock(&loop->wq_mutex);
-  QUEUE_INSERT_TAIL(&loop->wq, &w->wq);
-  uv_async_send(&loop->wq_async);
-  uv_mutex_unlock(&loop->wq_mutex);
-
-  return 0;
-}
-
-
-void uv__work_done(uv_async_t* handle) {
-  struct uv__work* w;
-  uv_loop_t* loop;
-  QUEUE* q;
-  QUEUE wq;
-  int err;
-
-  loop = container_of(handle, uv_loop_t, wq_async);
-  uv_mutex_lock(&loop->wq_mutex);
-  QUEUE_MOVE(&loop->wq, &wq);
-  uv_mutex_unlock(&loop->wq_mutex);
-
-  while (!QUEUE_EMPTY(&wq)) {
-    q = QUEUE_HEAD(&wq);
-    QUEUE_REMOVE(q);
-
-    w = container_of(q, struct uv__work, wq);
-    err = (w->work == uv__cancelled) ? UV_ECANCELED : 0;
-    w->done(w, err);
-  }
-}
-
-
-static void uv__queue_work(struct uv__work* w) {
-  uv_work_t* req = container_of(w, uv_work_t, work_req);
-
-  req->work_cb(req);
-}
-
-
-static void uv__queue_done(struct uv__work* w, int err) {
-  uv_work_t* req;
-
-  req = container_of(w, uv_work_t, work_req);
-  uv__req_unregister(req->loop, req);
-
-  if (req->after_work_cb == NULL)
-    return;
-
-  req->after_work_cb(req, err);
-}
-
-
-int uv_queue_work(uv_loop_t* loop,
-                  uv_work_t* req,
-                  uv_work_cb work_cb,
-                  uv_after_work_cb after_work_cb) {
-  if (work_cb == NULL)
-    return UV_EINVAL;
-
-  uv__req_init(loop, req, UV_WORK);
-  req->loop = loop;
-  req->work_cb = work_cb;
-  req->after_work_cb = after_work_cb;
-  uv__work_submit(loop,
-                  &req->work_req,
-                  UV__WORK_CPU,
-                  uv__queue_work,
-                  uv__queue_done);
-  return 0;
-}
-
-
-int uv_cancel(uv_req_t* req) {
-  struct uv__work* wreq;
-  uv_loop_t* loop;
-
-  switch (req->type) {
-  case UV_FS:
-    loop =  ((uv_fs_t*) req)->loop;
-    wreq = &((uv_fs_t*) req)->work_req;
-    break;
-  case UV_GETADDRINFO:
-    loop =  ((uv_getaddrinfo_t*) req)->loop;
-    wreq = &((uv_getaddrinfo_t*) req)->work_req;
-    break;
-  case UV_GETNAMEINFO:
-    loop = ((uv_getnameinfo_t*) req)->loop;
-    wreq = &((uv_getnameinfo_t*) req)->work_req;
-    break;
-  case UV_WORK:
-    loop =  ((uv_work_t*) req)->loop;
-    wreq = &((uv_work_t*) req)->work_req;
-    break;
-  default:
-    return UV_EINVAL;
-  }
-
-  return uv__work_cancel(loop, req, wreq);
-}
diff --git a/wpiutil/src/main/native/libuv/src/timer.cpp b/wpiutil/src/main/native/libuv/src/timer.cpp
deleted file mode 100644
index dd78bcb..0000000
--- a/wpiutil/src/main/native/libuv/src/timer.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "uv-common.h"
-#include "heap-inl.h"
-
-#include <assert.h>
-#include <limits.h>
-
-
-static struct heap *timer_heap(const uv_loop_t* loop) {
-#ifdef _WIN32
-  return (struct heap*) loop->timer_heap;
-#else
-  return (struct heap*) &loop->timer_heap;
-#endif
-}
-
-
-static int timer_less_than(const struct heap_node* ha,
-                           const struct heap_node* hb) {
-  const uv_timer_t* a;
-  const uv_timer_t* b;
-
-  a = container_of(ha, uv_timer_t, heap_node);
-  b = container_of(hb, uv_timer_t, heap_node);
-
-  if (a->timeout < b->timeout)
-    return 1;
-  if (b->timeout < a->timeout)
-    return 0;
-
-  /* Compare start_id when both have the same timeout. start_id is
-   * allocated with loop->timer_counter in uv_timer_start().
-   */
-  if (a->start_id < b->start_id)
-    return 1;
-  if (b->start_id < a->start_id)
-    return 0;
-
-  return 0;
-}
-
-
-int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER);
-  handle->timer_cb = NULL;
-  handle->repeat = 0;
-  return 0;
-}
-
-
-int uv_timer_start(uv_timer_t* handle,
-                   uv_timer_cb cb,
-                   uint64_t timeout,
-                   uint64_t repeat) {
-  uint64_t clamped_timeout;
-
-  if (cb == NULL)
-    return UV_EINVAL;
-
-  if (uv__is_active(handle))
-    uv_timer_stop(handle);
-
-  clamped_timeout = handle->loop->time + timeout;
-  if (clamped_timeout < timeout)
-    clamped_timeout = (uint64_t) -1;
-
-  handle->timer_cb = cb;
-  handle->timeout = clamped_timeout;
-  handle->repeat = repeat;
-  /* start_id is the second index to be compared in uv__timer_cmp() */
-  handle->start_id = handle->loop->timer_counter++;
-
-  heap_insert(timer_heap(handle->loop),
-              (struct heap_node*) &handle->heap_node,
-              timer_less_than);
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-int uv_timer_stop(uv_timer_t* handle) {
-  if (!uv__is_active(handle))
-    return 0;
-
-  heap_remove(timer_heap(handle->loop),
-              (struct heap_node*) &handle->heap_node,
-              timer_less_than);
-  uv__handle_stop(handle);
-
-  return 0;
-}
-
-
-int uv_timer_again(uv_timer_t* handle) {
-  if (handle->timer_cb == NULL)
-    return UV_EINVAL;
-
-  if (handle->repeat) {
-    uv_timer_stop(handle);
-    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
-  }
-
-  return 0;
-}
-
-
-void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) {
-  handle->repeat = repeat;
-}
-
-
-uint64_t uv_timer_get_repeat(const uv_timer_t* handle) {
-  return handle->repeat;
-}
-
-
-int uv__next_timeout(const uv_loop_t* loop) {
-  const struct heap_node* heap_node;
-  const uv_timer_t* handle;
-  uint64_t diff;
-
-  heap_node = heap_min(timer_heap(loop));
-  if (heap_node == NULL)
-    return -1; /* block indefinitely */
-
-  handle = container_of(heap_node, uv_timer_t, heap_node);
-  if (handle->timeout <= loop->time)
-    return 0;
-
-  diff = handle->timeout - loop->time;
-  if (diff > INT_MAX)
-    diff = INT_MAX;
-
-  return (int) diff;
-}
-
-
-void uv__run_timers(uv_loop_t* loop) {
-  struct heap_node* heap_node;
-  uv_timer_t* handle;
-
-  for (;;) {
-    heap_node = heap_min(timer_heap(loop));
-    if (heap_node == NULL)
-      break;
-
-    handle = container_of(heap_node, uv_timer_t, heap_node);
-    if (handle->timeout > loop->time)
-      break;
-
-    uv_timer_stop(handle);
-    uv_timer_again(handle);
-    handle->timer_cb(handle);
-  }
-}
-
-
-void uv__timer_close(uv_timer_t* handle) {
-  uv_timer_stop(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/android-ifaddrs.cpp b/wpiutil/src/main/native/libuv/src/unix/android-ifaddrs.cpp
deleted file mode 100644
index ab6b029..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/android-ifaddrs.cpp
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
-Copyright (c) 2013, Kenneth MacKay
-Copyright (c) 2014, Emergya (Cloud4all, FP7/2007-2013 grant agreement #289016)
-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.
-
-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.
-*/
-
-#include "uv/android-ifaddrs.h"
-#include "uv-common.h"
-
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/socket.h>
-#include <net/if_arp.h>
-#include <netinet/in.h>
-#include <linux/netlink.h>
-#include <linux/rtnetlink.h>
-
-typedef struct NetlinkList
-{
-    struct NetlinkList *m_next;
-    struct nlmsghdr *m_data;
-    unsigned int m_size;
-} NetlinkList;
-
-static int netlink_socket(pid_t *p_pid)
-{
-    struct sockaddr_nl l_addr;
-    socklen_t l_len;
-
-    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
-    if(l_socket < 0)
-    {
-        return -1;
-    }
-
-    memset(&l_addr, 0, sizeof(l_addr));
-    l_addr.nl_family = AF_NETLINK;
-    if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
-    {
-        close(l_socket);
-        return -1;
-    }
-
-    l_len = sizeof(l_addr);
-    if(getsockname(l_socket, (struct sockaddr *)&l_addr, &l_len) < 0)
-    {
-        close(l_socket);
-        return -1;
-    }
-    *p_pid = l_addr.nl_pid;
-
-    return l_socket;
-}
-
-static int netlink_send(int p_socket, int p_request)
-{
-    char l_buffer[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + NLMSG_ALIGN(sizeof(struct rtgenmsg))];
-
-    struct nlmsghdr *l_hdr;
-    struct rtgenmsg *l_msg;
-    struct sockaddr_nl l_addr;
-
-    memset(l_buffer, 0, sizeof(l_buffer));
-
-    l_hdr = (struct nlmsghdr *)l_buffer;
-    l_msg = (struct rtgenmsg *)NLMSG_DATA(l_hdr);
-
-    l_hdr->nlmsg_len = NLMSG_LENGTH(sizeof(*l_msg));
-    l_hdr->nlmsg_type = p_request;
-    l_hdr->nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
-    l_hdr->nlmsg_pid = 0;
-    l_hdr->nlmsg_seq = p_socket;
-    l_msg->rtgen_family = AF_UNSPEC;
-
-    memset(&l_addr, 0, sizeof(l_addr));
-    l_addr.nl_family = AF_NETLINK;
-    return (sendto(p_socket, l_hdr, l_hdr->nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
-}
-
-static int netlink_recv(int p_socket, void *p_buffer, size_t p_len)
-{
-    struct sockaddr_nl l_addr;
-    struct msghdr l_msg;
-
-    struct iovec l_iov;
-    l_iov.iov_base = p_buffer;
-    l_iov.iov_len = p_len;
-
-    for(;;)
-    {
-        int l_result;
-        l_msg.msg_name = (void *)&l_addr;
-        l_msg.msg_namelen = sizeof(l_addr);
-        l_msg.msg_iov = &l_iov;
-        l_msg.msg_iovlen = 1;
-        l_msg.msg_control = NULL;
-        l_msg.msg_controllen = 0;
-        l_msg.msg_flags = 0;
-        l_result = recvmsg(p_socket, &l_msg, 0);
-
-        if(l_result < 0)
-        {
-            if(errno == EINTR)
-            {
-                continue;
-            }
-            return -2;
-        }
-
-        /* Buffer was too small */
-        if(l_msg.msg_flags & MSG_TRUNC)
-        {
-            return -1;
-        }
-        return l_result;
-    }
-}
-
-static struct nlmsghdr *getNetlinkResponse(int p_socket, pid_t p_pid, int *p_size, int *p_done)
-{
-    size_t l_size = 4096;
-    void *l_buffer = NULL;
-
-    for(;;)
-    {
-        int l_read;
-
-        uv__free(l_buffer);
-        l_buffer = uv__malloc(l_size);
-        if (l_buffer == NULL)
-        {
-            return NULL;
-        }
-
-        l_read = netlink_recv(p_socket, l_buffer, l_size);
-        *p_size = l_read;
-        if(l_read == -2)
-        {
-            uv__free(l_buffer);
-            return NULL;
-        }
-        if(l_read >= 0)
-        {
-            struct nlmsghdr *l_hdr;
-            for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
-            {
-                if((pid_t)l_hdr->nlmsg_pid != p_pid || (int)l_hdr->nlmsg_seq != p_socket)
-                {
-                    continue;
-                }
-
-                if(l_hdr->nlmsg_type == NLMSG_DONE)
-                {
-                    *p_done = 1;
-                    break;
-                }
-
-                if(l_hdr->nlmsg_type == NLMSG_ERROR)
-                {
-                    uv__free(l_buffer);
-                    return NULL;
-                }
-            }
-            return l_buffer;
-        }
-
-        l_size *= 2;
-    }
-}
-
-static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
-{
-    NetlinkList *l_item = (NetlinkList*)uv__malloc(sizeof(NetlinkList));
-    if (l_item == NULL)
-    {
-        return NULL;
-    }
-
-    l_item->m_next = NULL;
-    l_item->m_data = p_data;
-    l_item->m_size = p_size;
-    return l_item;
-}
-
-static void freeResultList(NetlinkList *p_list)
-{
-    NetlinkList *l_cur;
-    while(p_list)
-    {
-        l_cur = p_list;
-        p_list = p_list->m_next;
-        uv__free(l_cur->m_data);
-        uv__free(l_cur);
-    }
-}
-
-static NetlinkList *getResultList(int p_socket, int p_request, pid_t p_pid)
-{
-    int l_size;
-    int l_done;
-    NetlinkList *l_list;
-    NetlinkList *l_end;
-
-    if(netlink_send(p_socket, p_request) < 0)
-    {
-        return NULL;
-    }
-
-    l_list = NULL;
-    l_end = NULL;
-
-    l_done = 0;
-    while(!l_done)
-    {
-        NetlinkList *l_item;
-
-        struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, p_pid, &l_size, &l_done);
-        /* Error */
-        if(!l_hdr)
-        {
-            freeResultList(l_list);
-            return NULL;
-        }
-
-        l_item = newListItem(l_hdr, l_size);
-        if (!l_item)
-        {
-            freeResultList(l_list);
-            return NULL;
-        }
-        if(!l_list)
-        {
-            l_list = l_item;
-        }
-        else
-        {
-            l_end->m_next = l_item;
-        }
-        l_end = l_item;
-    }
-    return l_list;
-}
-
-static size_t maxSize(size_t a, size_t b)
-{
-    return (a > b ? a : b);
-}
-
-static size_t calcAddrLen(sa_family_t p_family, int p_dataSize)
-{
-    switch(p_family)
-    {
-        case AF_INET:
-            return sizeof(struct sockaddr_in);
-        case AF_INET6:
-            return sizeof(struct sockaddr_in6);
-        case AF_PACKET:
-            return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
-        default:
-            return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
-    }
-}
-
-static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_data, size_t p_size)
-{
-    switch(p_family)
-    {
-        case AF_INET:
-            memcpy(&((struct sockaddr_in*)p_dest)->sin_addr, p_data, p_size);
-            break;
-        case AF_INET6:
-            memcpy(&((struct sockaddr_in6*)p_dest)->sin6_addr, p_data, p_size);
-            break;
-        case AF_PACKET:
-            memcpy(((struct sockaddr_ll*)p_dest)->sll_addr, p_data, p_size);
-            ((struct sockaddr_ll*)p_dest)->sll_halen = p_size;
-            break;
-        default:
-            memcpy(p_dest->sa_data, p_data, p_size);
-            break;
-    }
-    p_dest->sa_family = p_family;
-}
-
-static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry)
-{
-    if(!*p_resultList)
-    {
-        *p_resultList = p_entry;
-    }
-    else
-    {
-        struct ifaddrs *l_cur = *p_resultList;
-        while(l_cur->ifa_next)
-        {
-            l_cur = l_cur->ifa_next;
-        }
-        l_cur->ifa_next = p_entry;
-    }
-}
-
-static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
-{
-    struct ifaddrs *l_entry;
-
-    char *l_index;
-    char *l_name;
-    char *l_addr;
-    char *l_data;
-
-    struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
-
-    size_t l_nameSize = 0;
-    size_t l_addrSize = 0;
-    size_t l_dataSize = 0;
-
-    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
-    struct rtattr *l_rta;
-    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFLA_ADDRESS:
-            case IFLA_BROADCAST:
-                l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
-                break;
-            case IFLA_IFNAME:
-                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
-                break;
-            case IFLA_STATS:
-                l_dataSize += NLMSG_ALIGN(l_rtaSize);
-                break;
-            default:
-                break;
-        }
-    }
-
-    l_entry = (struct ifaddrs*)uv__malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
-    if (l_entry == NULL)
-    {
-        return -1;
-    }
-    memset(l_entry, 0, sizeof(struct ifaddrs));
-    l_entry->ifa_name = "";
-
-    l_index = ((char *)l_entry) + sizeof(struct ifaddrs);
-    l_name = l_index + sizeof(int);
-    l_addr = l_name + l_nameSize;
-    l_data = l_addr + l_addrSize;
-
-    /* Save the interface index so we can look it up when handling the
-     * addresses.
-     */
-    memcpy(l_index, &l_info->ifi_index, sizeof(int));
-
-    l_entry->ifa_flags = l_info->ifi_flags;
-
-    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
-    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        void *l_rtaData = RTA_DATA(l_rta);
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFLA_ADDRESS:
-            case IFLA_BROADCAST:
-            {
-                size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
-                makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
-                ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
-                ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
-                if(l_rta->rta_type == IFLA_ADDRESS)
-                {
-                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                }
-                else
-                {
-                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
-                }
-                l_addr += NLMSG_ALIGN(l_addrLen);
-                break;
-            }
-            case IFLA_IFNAME:
-                strncpy(l_name, l_rtaData, l_rtaDataSize);
-                l_name[l_rtaDataSize] = '\0';
-                l_entry->ifa_name = l_name;
-                break;
-            case IFLA_STATS:
-                memcpy(l_data, l_rtaData, l_rtaDataSize);
-                l_entry->ifa_data = l_data;
-                break;
-            default:
-                break;
-        }
-    }
-
-    addToEnd(p_resultList, l_entry);
-    return 0;
-}
-
-static struct ifaddrs *findInterface(int p_index, struct ifaddrs **p_links, int p_numLinks)
-{
-    int l_num = 0;
-    struct ifaddrs *l_cur = *p_links;
-    while(l_cur && l_num < p_numLinks)
-    {
-        char *l_indexPtr = ((char *)l_cur) + sizeof(struct ifaddrs);
-        int l_index;
-        memcpy(&l_index, l_indexPtr, sizeof(int));
-        if(l_index == p_index)
-        {
-            return l_cur;
-        }
-
-        l_cur = l_cur->ifa_next;
-        ++l_num;
-    }
-    return NULL;
-}
-
-static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList, int p_numLinks)
-{
-    struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
-    struct ifaddrs *l_interface = findInterface(l_info->ifa_index, p_resultList, p_numLinks);
-
-    size_t l_nameSize = 0;
-    size_t l_addrSize = 0;
-
-    int l_addedNetmask = 0;
-
-    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-    struct rtattr *l_rta;
-    struct ifaddrs *l_entry;
-
-    char *l_name;
-    char *l_addr;
-
-    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        if(l_info->ifa_family == AF_PACKET)
-        {
-            continue;
-        }
-
-        switch(l_rta->rta_type)
-        {
-            case IFA_ADDRESS:
-            case IFA_LOCAL:
-                if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
-                {
-                    /* Make room for netmask */
-                    l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
-                    l_addedNetmask = 1;
-                }
-            case IFA_BROADCAST:
-                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
-                break;
-            case IFA_LABEL:
-                l_nameSize += NLMSG_ALIGN(l_rtaDataSize + 1);
-                break;
-            default:
-                break;
-        }
-    }
-
-    l_entry = (struct ifaddrs*)uv__malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
-    if (l_entry == NULL)
-    {
-        return -1;
-    }
-    memset(l_entry, 0, sizeof(struct ifaddrs));
-    l_entry->ifa_name = (l_interface ? l_interface->ifa_name : "");
-
-    l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
-    l_addr = l_name + l_nameSize;
-
-    l_entry->ifa_flags = l_info->ifa_flags;
-    if(l_interface)
-    {
-        l_entry->ifa_flags |= l_interface->ifa_flags;
-    }
-
-    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
-    {
-        void *l_rtaData = RTA_DATA(l_rta);
-        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
-        switch(l_rta->rta_type)
-        {
-            case IFA_ADDRESS:
-            case IFA_BROADCAST:
-            case IFA_LOCAL:
-            {
-                size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
-                makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
-                if(l_info->ifa_family == AF_INET6)
-                {
-                    if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
-                    {
-                        ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
-                    }
-                }
-
-                /* Apparently in a point-to-point network IFA_ADDRESS contains
-                 * the dest address and IFA_LOCAL contains the local address
-                 */
-                if(l_rta->rta_type == IFA_ADDRESS)
-                {
-                    if(l_entry->ifa_addr)
-                    {
-                        l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
-                    }
-                    else
-                    {
-                        l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                    }
-                }
-                else if(l_rta->rta_type == IFA_LOCAL)
-                {
-                    if(l_entry->ifa_addr)
-                    {
-                        l_entry->ifa_dstaddr = l_entry->ifa_addr;
-                    }
-                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
-                }
-                else
-                {
-                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
-                }
-                l_addr += NLMSG_ALIGN(l_addrLen);
-                break;
-            }
-            case IFA_LABEL:
-                strncpy(l_name, l_rtaData, l_rtaDataSize);
-                l_name[l_rtaDataSize] = '\0';
-                l_entry->ifa_name = l_name;
-                break;
-            default:
-                break;
-        }
-    }
-
-    if(l_entry->ifa_addr && (l_entry->ifa_addr->sa_family == AF_INET || l_entry->ifa_addr->sa_family == AF_INET6))
-    {
-        unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET ? 32 : 128);
-        unsigned l_prefix = (l_info->ifa_prefixlen > l_maxPrefix ? l_maxPrefix : l_info->ifa_prefixlen);
-        unsigned char l_mask[16] = {0};
-        unsigned i;
-        for(i=0; i<(l_prefix/8); ++i)
-        {
-            l_mask[i] = 0xff;
-        }
-        if(l_prefix % 8)
-        {
-            l_mask[i] = 0xff << (8 - (l_prefix % 8));
-        }
-
-        makeSockaddr(l_entry->ifa_addr->sa_family, (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
-        l_entry->ifa_netmask = (struct sockaddr *)l_addr;
-    }
-
-    addToEnd(p_resultList, l_entry);
-    return 0;
-}
-
-static int interpretLinks(int p_socket, pid_t p_pid, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList)
-{
-
-    int l_numLinks = 0;
-    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
-    {
-        unsigned int l_nlsize = p_netlinkList->m_size;
-        struct nlmsghdr *l_hdr;
-        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
-        {
-            if((pid_t)l_hdr->nlmsg_pid != p_pid || (int)l_hdr->nlmsg_seq != p_socket)
-            {
-                continue;
-            }
-
-            if(l_hdr->nlmsg_type == NLMSG_DONE)
-            {
-                break;
-            }
-
-            if(l_hdr->nlmsg_type == RTM_NEWLINK)
-            {
-                if(interpretLink(l_hdr, p_resultList) == -1)
-                {
-                    return -1;
-                }
-                ++l_numLinks;
-            }
-        }
-    }
-    return l_numLinks;
-}
-
-static int interpretAddrs(int p_socket, pid_t p_pid, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList, int p_numLinks)
-{
-    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
-    {
-        unsigned int l_nlsize = p_netlinkList->m_size;
-        struct nlmsghdr *l_hdr;
-        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
-        {
-            if((pid_t)l_hdr->nlmsg_pid != p_pid || (int)l_hdr->nlmsg_seq != p_socket)
-            {
-                continue;
-            }
-
-            if(l_hdr->nlmsg_type == NLMSG_DONE)
-            {
-                break;
-            }
-
-            if(l_hdr->nlmsg_type == RTM_NEWADDR)
-            {
-                if (interpretAddr(l_hdr, p_resultList, p_numLinks) == -1)
-                {
-                    return -1;
-                }
-            }
-        }
-    }
-    return 0;
-}
-
-int getifaddrs(struct ifaddrs **ifap)
-{
-    int l_socket;
-    int l_result;
-    int l_numLinks;
-    pid_t l_pid;
-    NetlinkList *l_linkResults;
-    NetlinkList *l_addrResults;
-
-    if(!ifap)
-    {
-        return -1;
-    }
-    *ifap = NULL;
-
-    l_socket = netlink_socket(&l_pid);
-    if(l_socket < 0)
-    {
-        return -1;
-    }
-
-    l_linkResults = getResultList(l_socket, RTM_GETLINK, l_pid);
-    if(!l_linkResults)
-    {
-        close(l_socket);
-        return -1;
-    }
-
-    l_addrResults = getResultList(l_socket, RTM_GETADDR, l_pid);
-    if(!l_addrResults)
-    {
-        close(l_socket);
-        freeResultList(l_linkResults);
-        return -1;
-    }
-
-    l_result = 0;
-    l_numLinks = interpretLinks(l_socket, l_pid, l_linkResults, ifap);
-    if(l_numLinks == -1 || interpretAddrs(l_socket, l_pid, l_addrResults, ifap, l_numLinks) == -1)
-    {
-        l_result = -1;
-    }
-
-    freeResultList(l_linkResults);
-    freeResultList(l_addrResults);
-    close(l_socket);
-    return l_result;
-}
-
-void freeifaddrs(struct ifaddrs *ifa)
-{
-    struct ifaddrs *l_cur;
-    while(ifa)
-    {
-        l_cur = ifa;
-        ifa = ifa->ifa_next;
-        uv__free(l_cur);
-    }
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/async.cpp b/wpiutil/src/main/native/libuv/src/unix/async.cpp
deleted file mode 100644
index a5c47bc..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/async.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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.
- */
-
-/* This file contains both the uv__async internal infrastructure and the
- * user-facing uv_async_t functions.
- */
-
-#include "uv.h"
-#include "internal.h"
-#include "atomic-ops.h"
-
-#include <errno.h>
-#include <stdio.h>  /* snprintf() */
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-static void uv__async_send(uv_loop_t* loop);
-static int uv__async_start(uv_loop_t* loop);
-static int uv__async_eventfd(void);
-
-
-int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
-  int err;
-
-  err = uv__async_start(loop);
-  if (err)
-    return err;
-
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_ASYNC);
-  handle->async_cb = async_cb;
-  handle->pending = 0;
-
-  QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue);
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-int uv_async_send(uv_async_t* handle) {
-  /* Do a cheap read first. */
-  if (ACCESS_ONCE(int, handle->pending) != 0)
-    return 0;
-
-  /* Tell the other thread we're busy with the handle. */
-  if (cmpxchgi(&handle->pending, 0, 1) != 0)
-    return 0;
-
-  /* Wake up the other thread's event loop. */
-  uv__async_send(handle->loop);
-
-  /* Tell the other thread we're done. */
-  if (cmpxchgi(&handle->pending, 1, 2) != 1)
-    abort();
-
-  return 0;
-}
-
-
-/* Only call this from the event loop thread. */
-static int uv__async_spin(uv_async_t* handle) {
-  int rc;
-
-  for (;;) {
-    /* rc=0 -- handle is not pending.
-     * rc=1 -- handle is pending, other thread is still working with it.
-     * rc=2 -- handle is pending, other thread is done.
-     */
-    rc = cmpxchgi(&handle->pending, 2, 0);
-
-    if (rc != 1)
-      return rc;
-
-    /* Other thread is busy with this handle, spin until it's done. */
-    cpu_relax();
-  }
-}
-
-
-void uv__async_close(uv_async_t* handle) {
-  uv__async_spin(handle);
-  QUEUE_REMOVE(&handle->queue);
-  uv__handle_stop(handle);
-}
-
-
-static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  char buf[1024];
-  ssize_t r;
-  QUEUE queue;
-  QUEUE* q;
-  uv_async_t* h;
-
-  assert(w == &loop->async_io_watcher);
-
-  for (;;) {
-    r = read(w->fd, buf, sizeof(buf));
-
-    if (r == sizeof(buf))
-      continue;
-
-    if (r != -1)
-      break;
-
-    if (errno == EAGAIN || errno == EWOULDBLOCK)
-      break;
-
-    if (errno == EINTR)
-      continue;
-
-    abort();
-  }
-
-  QUEUE_MOVE(&loop->async_handles, &queue);
-  while (!QUEUE_EMPTY(&queue)) {
-    q = QUEUE_HEAD(&queue);
-    h = QUEUE_DATA(q, uv_async_t, queue);
-
-    QUEUE_REMOVE(q);
-    QUEUE_INSERT_TAIL(&loop->async_handles, q);
-
-    if (0 == uv__async_spin(h))
-      continue;  /* Not pending. */
-
-    if (h->async_cb == NULL)
-      continue;
-
-    h->async_cb(h);
-  }
-}
-
-
-static void uv__async_send(uv_loop_t* loop) {
-  const void* buf;
-  ssize_t len;
-  int fd;
-  int r;
-
-  buf = "";
-  len = 1;
-  fd = loop->async_wfd;
-
-#if defined(__linux__)
-  if (fd == -1) {
-    static const uint64_t val = 1;
-    buf = &val;
-    len = sizeof(val);
-    fd = loop->async_io_watcher.fd;  /* eventfd */
-  }
-#endif
-
-  do
-    r = write(fd, buf, len);
-  while (r == -1 && errno == EINTR);
-
-  if (r == len)
-    return;
-
-  if (r == -1)
-    if (errno == EAGAIN || errno == EWOULDBLOCK)
-      return;
-
-  abort();
-}
-
-
-static int uv__async_start(uv_loop_t* loop) {
-  int pipefd[2];
-  int err;
-
-  if (loop->async_io_watcher.fd != -1)
-    return 0;
-
-  err = uv__async_eventfd();
-  if (err >= 0) {
-    pipefd[0] = err;
-    pipefd[1] = -1;
-  }
-  else if (err == UV_ENOSYS) {
-    err = uv__make_pipe(pipefd, UV__F_NONBLOCK);
-#if defined(__linux__)
-    /* Save a file descriptor by opening one of the pipe descriptors as
-     * read/write through the procfs.  That file descriptor can then
-     * function as both ends of the pipe.
-     */
-    if (err == 0) {
-      char buf[32];
-      int fd;
-
-      snprintf(buf, sizeof(buf), "/proc/self/fd/%d", pipefd[0]);
-      fd = uv__open_cloexec(buf, O_RDWR);
-      if (fd >= 0) {
-        uv__close(pipefd[0]);
-        uv__close(pipefd[1]);
-        pipefd[0] = fd;
-        pipefd[1] = fd;
-      }
-    }
-#endif
-  }
-
-  if (err < 0)
-    return err;
-
-  uv__io_init(&loop->async_io_watcher, uv__async_io, pipefd[0]);
-  uv__io_start(loop, &loop->async_io_watcher, POLLIN);
-  loop->async_wfd = pipefd[1];
-
-  return 0;
-}
-
-
-int uv__async_fork(uv_loop_t* loop) {
-  if (loop->async_io_watcher.fd == -1) /* never started */
-    return 0;
-
-  uv__async_stop(loop);
-
-  return uv__async_start(loop);
-}
-
-
-void uv__async_stop(uv_loop_t* loop) {
-  if (loop->async_io_watcher.fd == -1)
-    return;
-
-  if (loop->async_wfd != -1) {
-    if (loop->async_wfd != loop->async_io_watcher.fd)
-      uv__close(loop->async_wfd);
-    loop->async_wfd = -1;
-  }
-
-  uv__io_stop(loop, &loop->async_io_watcher, POLLIN);
-  uv__close(loop->async_io_watcher.fd);
-  loop->async_io_watcher.fd = -1;
-}
-
-
-static int uv__async_eventfd(void) {
-#if defined(__linux__)
-  static int no_eventfd2;
-  static int no_eventfd;
-  int fd;
-
-  if (no_eventfd2)
-    goto skip_eventfd2;
-
-  fd = uv__eventfd2(0, UV__EFD_CLOEXEC | UV__EFD_NONBLOCK);
-  if (fd != -1)
-    return fd;
-
-  if (errno != ENOSYS)
-    return UV__ERR(errno);
-
-  no_eventfd2 = 1;
-
-skip_eventfd2:
-
-  if (no_eventfd)
-    goto skip_eventfd;
-
-  fd = uv__eventfd(0);
-  if (fd != -1) {
-    uv__cloexec(fd, 1);
-    uv__nonblock(fd, 1);
-    return fd;
-  }
-
-  if (errno != ENOSYS)
-    return UV__ERR(errno);
-
-  no_eventfd = 1;
-
-skip_eventfd:
-
-#endif
-
-  return UV_ENOSYS;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/atomic-ops.h b/wpiutil/src/main/native/libuv/src/unix/atomic-ops.h
deleted file mode 100644
index 541a6c8..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/atomic-ops.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef UV_ATOMIC_OPS_H_
-#define UV_ATOMIC_OPS_H_
-
-#include "internal.h"  /* UV_UNUSED */
-
-#if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-#include <atomic.h>
-#endif
-
-UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval));
-UV_UNUSED(static void cpu_relax(void));
-
-/* Prefer hand-rolled assembly over the gcc builtins because the latter also
- * issue full memory barriers.
- */
-UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval)) {
-#if defined(__i386__) || defined(__x86_64__)
-  int out;
-  __asm__ __volatile__ ("lock; cmpxchg %2, %1;"
-                        : "=a" (out), "+m" (*(volatile int*) ptr)
-                        : "r" (newval), "0" (oldval)
-                        : "memory");
-  return out;
-#elif defined(_AIX) && defined(__xlC__)
-  const int out = (*(volatile int*) ptr);
-  __compare_and_swap(ptr, &oldval, newval);
-  return out;
-#elif defined(__MVS__)
-  unsigned int op4;
-  if (__plo_CSST(ptr, (unsigned int*) &oldval, newval,
-                (unsigned int*) ptr, *ptr, &op4))
-    return oldval;
-  else
-    return op4;
-#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
-  return atomic_cas_uint((uint_t *)ptr, (uint_t)oldval, (uint_t)newval);
-#else
-  return __sync_val_compare_and_swap(ptr, oldval, newval);
-#endif
-}
-
-UV_UNUSED(static void cpu_relax(void)) {
-#if defined(__i386__) || defined(__x86_64__)
-  __asm__ __volatile__ ("rep; nop");  /* a.k.a. PAUSE */
-#endif
-}
-
-#endif  /* UV_ATOMIC_OPS_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/unix/bsd-ifaddrs.cpp b/wpiutil/src/main/native/libuv/src/unix/bsd-ifaddrs.cpp
deleted file mode 100644
index a01aa8d..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/bsd-ifaddrs.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <errno.h>
-#include <stddef.h>
-
-#include <ifaddrs.h>
-#include <net/if.h>
-#if !defined(__CYGWIN__) && !defined(__MSYS__)
-#include <net/if_dl.h>
-#endif
-
-#if defined(__HAIKU__)
-#define IFF_RUNNING IFF_LINK
-#endif
-
-static int uv__ifaddr_exclude(struct ifaddrs *ent, int exclude_type) {
-  if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)))
-    return 1;
-  if (ent->ifa_addr == NULL)
-    return 1;
-#if !defined(__CYGWIN__) && !defined(__MSYS__)
-  /*
-   * If `exclude_type` is `UV__EXCLUDE_IFPHYS`, just see whether `sa_family`
-   * equals to `AF_LINK` or not. Otherwise, the result depends on the operation
-   * system with `AF_LINK` or `PF_INET`.
-   */
-  if (exclude_type == UV__EXCLUDE_IFPHYS)
-    return (ent->ifa_addr->sa_family != AF_LINK);
-#endif
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__DragonFly__) || \
-    defined(__HAIKU__)
-  /*
-   * On BSD getifaddrs returns information related to the raw underlying
-   * devices.  We're not interested in this information.
-   */
-  if (ent->ifa_addr->sa_family == AF_LINK)
-    return 1;
-#elif defined(__NetBSD__) || defined(__OpenBSD__)
-  if (ent->ifa_addr->sa_family != PF_INET &&
-      ent->ifa_addr->sa_family != PF_INET6)
-    return 1;
-#endif
-  return 0;
-}
-
-int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
-  struct ifaddrs* addrs;
-  struct ifaddrs* ent;
-  uv_interface_address_t* address;
-  int i;
-
-  *count = 0;
-  *addresses = NULL;
-
-  if (getifaddrs(&addrs) != 0)
-    return UV__ERR(errno);
-
-  /* Count the number of interfaces */
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
-      continue;
-    (*count)++;
-  }
-
-  if (*count == 0) {
-    freeifaddrs(addrs);
-    return 0;
-  }
-
-  /* Make sure the memory is initiallized to zero using calloc() */
-  *addresses = (uv_interface_address_t*)uv__calloc(*count, sizeof(**addresses));
-
-  if (*addresses == NULL) {
-    freeifaddrs(addrs);
-    return UV_ENOMEM;
-  }
-
-  address = *addresses;
-
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
-      continue;
-
-    address->name = uv__strdup(ent->ifa_name);
-
-    if (ent->ifa_addr->sa_family == AF_INET6) {
-      address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr);
-    } else {
-      address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr);
-    }
-
-    if (ent->ifa_netmask->sa_family == AF_INET6) {
-      address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask);
-    } else {
-      address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask);
-    }
-
-    address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK);
-
-    address++;
-  }
-
-#if !(defined(__CYGWIN__) || defined(__MSYS__))
-  /* Fill in physical addresses for each interface */
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFPHYS))
-      continue;
-
-    address = *addresses;
-
-    for (i = 0; i < *count; i++) {
-      if (strcmp(address->name, ent->ifa_name) == 0) {
-        struct sockaddr_dl* sa_addr;
-        sa_addr = (struct sockaddr_dl*)(ent->ifa_addr);
-        memcpy(address->phys_addr, LLADDR(sa_addr), sizeof(address->phys_addr));
-      }
-      address++;
-    }
-  }
-#endif
-
-  freeifaddrs(addrs);
-
-  return 0;
-}
-
-
-void uv_free_interface_addresses(uv_interface_address_t* addresses,
-                                 int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(addresses[i].name);
-  }
-
-  uv__free(addresses);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/core.cpp b/wpiutil/src/main/native/libuv/src/unix/core.cpp
deleted file mode 100644
index 77bb337..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/core.cpp
+++ /dev/null
@@ -1,1509 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stddef.h> /* NULL */
-#include <stdio.h> /* printf */
-#include <stdlib.h>
-#include <string.h> /* strerror */
-#include <errno.h>
-#include <assert.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <limits.h> /* INT_MAX, PATH_MAX, IOV_MAX */
-#include <sys/uio.h> /* writev */
-#include <sys/resource.h> /* getrusage */
-#include <pwd.h>
-#include <sys/utsname.h>
-#include <sys/time.h>
-
-#ifdef __sun
-# include <sys/filio.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-#endif
-
-#ifdef __APPLE__
-# include <mach-o/dyld.h> /* _NSGetExecutablePath */
-# include <sys/filio.h>
-# if defined(O_CLOEXEC)
-#  define UV__O_CLOEXEC O_CLOEXEC
-# endif
-#endif
-
-#if defined(__DragonFly__)      || \
-    defined(__FreeBSD__)        || \
-    defined(__FreeBSD_kernel__) || \
-    defined(__NetBSD__)
-# include <sys/sysctl.h>
-# include <sys/filio.h>
-# include <sys/wait.h>
-# define UV__O_CLOEXEC O_CLOEXEC
-# if defined(__FreeBSD__) && __FreeBSD__ >= 10
-#  define uv__accept4 accept4
-# endif
-# if defined(__NetBSD__)
-#  define uv__accept4(a, b, c, d) paccept((a), (b), (c), NULL, (d))
-# endif
-# if (defined(__FreeBSD__) && __FreeBSD__ >= 10) || defined(__NetBSD__)
-#  define UV__SOCK_NONBLOCK SOCK_NONBLOCK
-#  define UV__SOCK_CLOEXEC  SOCK_CLOEXEC
-# endif
-# if !defined(F_DUP2FD_CLOEXEC) && defined(_F_DUP2FD_CLOEXEC)
-#  define F_DUP2FD_CLOEXEC  _F_DUP2FD_CLOEXEC
-# endif
-#endif
-
-#if defined(__ANDROID_API__) && __ANDROID_API__ < 21
-# include <dlfcn.h>  /* for dlsym */
-#endif
-
-#if defined(__MVS__)
-#include <sys/ioctl.h>
-#endif
-
-#if defined(__linux__)
-#include <sys/syscall.h>
-#endif
-
-static int uv__run_pending(uv_loop_t* loop);
-
-/* Verify that uv_buf_t is ABI-compatible with struct iovec. */
-STATIC_ASSERT(sizeof(uv_buf_t) == sizeof(struct iovec));
-STATIC_ASSERT(sizeof(&((uv_buf_t*) 0)->base) ==
-              sizeof(((struct iovec*) 0)->iov_base));
-STATIC_ASSERT(sizeof(&((uv_buf_t*) 0)->len) ==
-              sizeof(((struct iovec*) 0)->iov_len));
-STATIC_ASSERT(offsetof(uv_buf_t, base) == offsetof(struct iovec, iov_base));
-STATIC_ASSERT(offsetof(uv_buf_t, len) == offsetof(struct iovec, iov_len));
-
-
-uint64_t uv_hrtime(void) {
-  return uv__hrtime(UV_CLOCK_PRECISE);
-}
-
-
-void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
-  assert(!uv__is_closing(handle));
-
-  handle->flags |= UV_HANDLE_CLOSING;
-  handle->close_cb = close_cb;
-
-  switch (handle->type) {
-  case UV_NAMED_PIPE:
-    uv__pipe_close((uv_pipe_t*)handle);
-    break;
-
-  case UV_TTY:
-    uv__stream_close((uv_stream_t*)handle);
-    break;
-
-  case UV_TCP:
-    uv__tcp_close((uv_tcp_t*)handle);
-    break;
-
-  case UV_UDP:
-    uv__udp_close((uv_udp_t*)handle);
-    break;
-
-  case UV_PREPARE:
-    uv__prepare_close((uv_prepare_t*)handle);
-    break;
-
-  case UV_CHECK:
-    uv__check_close((uv_check_t*)handle);
-    break;
-
-  case UV_IDLE:
-    uv__idle_close((uv_idle_t*)handle);
-    break;
-
-  case UV_ASYNC:
-    uv__async_close((uv_async_t*)handle);
-    break;
-
-  case UV_TIMER:
-    uv__timer_close((uv_timer_t*)handle);
-    break;
-
-  case UV_PROCESS:
-    uv__process_close((uv_process_t*)handle);
-    break;
-
-  case UV_FS_EVENT:
-    uv__fs_event_close((uv_fs_event_t*)handle);
-    break;
-
-  case UV_POLL:
-    uv__poll_close((uv_poll_t*)handle);
-    break;
-
-  case UV_FS_POLL:
-    uv__fs_poll_close((uv_fs_poll_t*)handle);
-    /* Poll handles use file system requests, and one of them may still be
-     * running. The poll code will call uv__make_close_pending() for us. */
-    return;
-
-  case UV_SIGNAL:
-    uv__signal_close((uv_signal_t*) handle);
-    /* Signal handles may not be closed immediately. The signal code will
-     * itself close uv__make_close_pending whenever appropriate. */
-    return;
-
-  default:
-    assert(0);
-  }
-
-  uv__make_close_pending(handle);
-}
-
-int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value) {
-  int r;
-  int fd;
-  socklen_t len;
-
-  if (handle == NULL || value == NULL)
-    return UV_EINVAL;
-
-  if (handle->type == UV_TCP || handle->type == UV_NAMED_PIPE)
-    fd = uv__stream_fd((uv_stream_t*) handle);
-  else if (handle->type == UV_UDP)
-    fd = ((uv_udp_t *) handle)->io_watcher.fd;
-  else
-    return UV_ENOTSUP;
-
-  len = sizeof(*value);
-
-  if (*value == 0)
-    r = getsockopt(fd, SOL_SOCKET, optname, value, &len);
-  else
-    r = setsockopt(fd, SOL_SOCKET, optname, (const void*) value, len);
-
-  if (r < 0)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-void uv__make_close_pending(uv_handle_t* handle) {
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-  handle->next_closing = handle->loop->closing_handles;
-  handle->loop->closing_handles = handle;
-}
-
-int uv__getiovmax(void) {
-#if defined(IOV_MAX)
-  return IOV_MAX;
-#elif defined(_SC_IOV_MAX)
-  static int iovmax = -1;
-  if (iovmax == -1) {
-    iovmax = sysconf(_SC_IOV_MAX);
-    /* On some embedded devices (arm-linux-uclibc based ip camera),
-     * sysconf(_SC_IOV_MAX) can not get the correct value. The return
-     * value is -1 and the errno is EINPROGRESS. Degrade the value to 1.
-     */
-    if (iovmax == -1) iovmax = 1;
-  }
-  return iovmax;
-#else
-  return 1024;
-#endif
-}
-
-
-static void uv__finish_close(uv_handle_t* handle) {
-  /* Note: while the handle is in the UV_HANDLE_CLOSING state now, it's still
-   * possible for it to be active in the sense that uv__is_active() returns
-   * true.
-   *
-   * A good example is when the user calls uv_shutdown(), immediately followed
-   * by uv_close(). The handle is considered active at this point because the
-   * completion of the shutdown req is still pending.
-   */
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-  handle->flags |= UV_HANDLE_CLOSED;
-
-  switch (handle->type) {
-    case UV_PREPARE:
-    case UV_CHECK:
-    case UV_IDLE:
-    case UV_ASYNC:
-    case UV_TIMER:
-    case UV_PROCESS:
-    case UV_FS_EVENT:
-    case UV_FS_POLL:
-    case UV_POLL:
-    case UV_SIGNAL:
-      break;
-
-    case UV_NAMED_PIPE:
-    case UV_TCP:
-    case UV_TTY:
-      uv__stream_destroy((uv_stream_t*)handle);
-      break;
-
-    case UV_UDP:
-      uv__udp_finish_close((uv_udp_t*)handle);
-      break;
-
-    default:
-      assert(0);
-      break;
-  }
-
-  uv__handle_unref(handle);
-  QUEUE_REMOVE(&handle->handle_queue);
-
-  if (handle->close_cb) {
-    handle->close_cb(handle);
-  }
-}
-
-
-static void uv__run_closing_handles(uv_loop_t* loop) {
-  uv_handle_t* p;
-  uv_handle_t* q;
-
-  p = loop->closing_handles;
-  loop->closing_handles = NULL;
-
-  while (p) {
-    q = p->next_closing;
-    uv__finish_close(p);
-    p = q;
-  }
-}
-
-
-int uv_is_closing(const uv_handle_t* handle) {
-  return uv__is_closing(handle);
-}
-
-
-int uv_backend_fd(const uv_loop_t* loop) {
-  return loop->backend_fd;
-}
-
-
-int uv_backend_timeout(const uv_loop_t* loop) {
-  if (loop->stop_flag != 0)
-    return 0;
-
-  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
-    return 0;
-
-  if (!QUEUE_EMPTY(&loop->idle_handles))
-    return 0;
-
-  if (!QUEUE_EMPTY(&loop->pending_queue))
-    return 0;
-
-  if (loop->closing_handles)
-    return 0;
-
-  return uv__next_timeout(loop);
-}
-
-
-static int uv__loop_alive(const uv_loop_t* loop) {
-  return uv__has_active_handles(loop) ||
-         uv__has_active_reqs(loop) ||
-         loop->closing_handles != NULL;
-}
-
-
-int uv_loop_alive(const uv_loop_t* loop) {
-    return uv__loop_alive(loop);
-}
-
-
-int uv_run(uv_loop_t* loop, uv_run_mode mode) {
-  int timeout;
-  int r;
-  int ran_pending;
-
-  r = uv__loop_alive(loop);
-  if (!r)
-    uv__update_time(loop);
-
-  while (r != 0 && loop->stop_flag == 0) {
-    uv__update_time(loop);
-    uv__run_timers(loop);
-    ran_pending = uv__run_pending(loop);
-    uv__run_idle(loop);
-    uv__run_prepare(loop);
-
-    timeout = 0;
-    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
-      timeout = uv_backend_timeout(loop);
-
-    uv__io_poll(loop, timeout);
-    uv__run_check(loop);
-    uv__run_closing_handles(loop);
-
-    if (mode == UV_RUN_ONCE) {
-      /* UV_RUN_ONCE implies forward progress: at least one callback must have
-       * been invoked when it returns. uv__io_poll() can return without doing
-       * I/O (meaning: no callbacks) when its timeout expires - which means we
-       * have pending timers that satisfy the forward progress constraint.
-       *
-       * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
-       * the check.
-       */
-      uv__update_time(loop);
-      uv__run_timers(loop);
-    }
-
-    r = uv__loop_alive(loop);
-    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
-      break;
-  }
-
-  /* The if statement lets gcc compile it to a conditional store. Avoids
-   * dirtying a cache line.
-   */
-  if (loop->stop_flag != 0)
-    loop->stop_flag = 0;
-
-  return r;
-}
-
-
-void uv_update_time(uv_loop_t* loop) {
-  uv__update_time(loop);
-}
-
-
-int uv_is_active(const uv_handle_t* handle) {
-  return uv__is_active(handle);
-}
-
-
-/* Open a socket in non-blocking close-on-exec mode, atomically if possible. */
-int uv__socket(int domain, int type, int protocol) {
-  int sockfd;
-  int err;
-
-#if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
-  sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
-  if (sockfd != -1)
-    return sockfd;
-
-  if (errno != EINVAL)
-    return UV__ERR(errno);
-#endif
-
-  sockfd = socket(domain, type, protocol);
-  if (sockfd == -1)
-    return UV__ERR(errno);
-
-  err = uv__nonblock(sockfd, 1);
-  if (err == 0)
-    err = uv__cloexec(sockfd, 1);
-
-  if (err) {
-    uv__close(sockfd);
-    return err;
-  }
-
-#if defined(SO_NOSIGPIPE)
-  {
-    int on = 1;
-    setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
-  }
-#endif
-
-  return sockfd;
-}
-
-/* get a file pointer to a file in read-only and close-on-exec mode */
-FILE* uv__open_file(const char* path) {
-  int fd;
-  FILE* fp;
-
-  fd = uv__open_cloexec(path, O_RDONLY);
-  if (fd < 0)
-    return NULL;
-
-   fp = fdopen(fd, "r");
-   if (fp == NULL)
-     uv__close(fd);
-
-   return fp;
-}
-
-
-int uv__accept(int sockfd) {
-  int peerfd;
-  int err;
-
-  assert(sockfd >= 0);
-
-  while (1) {
-#if defined(__linux__)                          || \
-    (defined(__FreeBSD__) && __FreeBSD__ >= 10) || \
-    defined(__NetBSD__)
-    static int no_accept4;
-
-    if (no_accept4)
-      goto skip;
-
-    peerfd = uv__accept4(sockfd,
-                         NULL,
-                         NULL,
-                         UV__SOCK_NONBLOCK|UV__SOCK_CLOEXEC);
-    if (peerfd != -1)
-      return peerfd;
-
-    if (errno == EINTR)
-      continue;
-
-    if (errno != ENOSYS)
-      return UV__ERR(errno);
-
-    no_accept4 = 1;
-skip:
-#endif
-
-    peerfd = accept(sockfd, NULL, NULL);
-    if (peerfd == -1) {
-      if (errno == EINTR)
-        continue;
-      return UV__ERR(errno);
-    }
-
-    err = uv__cloexec(peerfd, 1);
-    if (err == 0)
-      err = uv__nonblock(peerfd, 1);
-
-    if (err) {
-      uv__close(peerfd);
-      return err;
-    }
-
-    return peerfd;
-  }
-}
-
-
-#if defined(__APPLE__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdollar-in-identifier-extension"
-#if defined(__LP64__)
-  extern "C" int close$NOCANCEL(int);
-#else
-  extern "C" int close$NOCANCEL$UNIX2003(int);
-#endif
-#pragma GCC diagnostic pop
-#endif
-
-/* close() on macos has the "interesting" quirk that it fails with EINTR
- * without closing the file descriptor when a thread is in the cancel state.
- * That's why libuv calls close$NOCANCEL() instead.
- *
- * glibc on linux has a similar issue: close() is a cancellation point and
- * will unwind the thread when it's in the cancel state. Work around that
- * by making the system call directly. Musl libc is unaffected.
- */
-int uv__close_nocancel(int fd) {
-#if defined(__APPLE__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdollar-in-identifier-extension"
-#if defined(__LP64__)
-  return close$NOCANCEL(fd);
-#else
-  return close$NOCANCEL$UNIX2003(fd);
-#endif
-#pragma GCC diagnostic pop
-#elif defined(__linux__)
-  return syscall(SYS_close, fd);
-#else
-  return close(fd);
-#endif
-}
-
-
-int uv__close_nocheckstdio(int fd) {
-  int saved_errno;
-  int rc;
-
-  assert(fd > -1);  /* Catch uninitialized io_watcher.fd bugs. */
-
-  saved_errno = errno;
-  rc = uv__close_nocancel(fd);
-  if (rc == -1) {
-    rc = UV__ERR(errno);
-    if (rc == UV_EINTR || rc == UV__ERR(EINPROGRESS))
-      rc = 0;    /* The close is in progress, not an error. */
-    errno = saved_errno;
-  }
-
-  return rc;
-}
-
-
-int uv__close(int fd) {
-  assert(fd > STDERR_FILENO);  /* Catch stdio close bugs. */
-#if defined(__MVS__)
-  SAVE_ERRNO(epoll_file_close(fd));
-#endif
-  return uv__close_nocheckstdio(fd);
-}
-
-
-int uv__nonblock_ioctl(int fd, int set) {
-  int r;
-
-  do
-    r = ioctl(fd, FIONBIO, &set);
-  while (r == -1 && errno == EINTR);
-
-  if (r)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-#if !defined(__CYGWIN__) && !defined(__MSYS__) && !defined(__HAIKU__)
-int uv__cloexec_ioctl(int fd, int set) {
-  int r;
-
-  do
-    r = ioctl(fd, set ? FIOCLEX : FIONCLEX);
-  while (r == -1 && errno == EINTR);
-
-  if (r)
-    return UV__ERR(errno);
-
-  return 0;
-}
-#endif
-
-
-int uv__nonblock_fcntl(int fd, int set) {
-  int flags;
-  int r;
-
-  do
-    r = fcntl(fd, F_GETFL);
-  while (r == -1 && errno == EINTR);
-
-  if (r == -1)
-    return UV__ERR(errno);
-
-  /* Bail out now if already set/clear. */
-  if (!!(r & O_NONBLOCK) == !!set)
-    return 0;
-
-  if (set)
-    flags = r | O_NONBLOCK;
-  else
-    flags = r & ~O_NONBLOCK;
-
-  do
-    r = fcntl(fd, F_SETFL, flags);
-  while (r == -1 && errno == EINTR);
-
-  if (r)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-int uv__cloexec_fcntl(int fd, int set) {
-  int flags;
-  int r;
-
-  do
-    r = fcntl(fd, F_GETFD);
-  while (r == -1 && errno == EINTR);
-
-  if (r == -1)
-    return UV__ERR(errno);
-
-  /* Bail out now if already set/clear. */
-  if (!!(r & FD_CLOEXEC) == !!set)
-    return 0;
-
-  if (set)
-    flags = r | FD_CLOEXEC;
-  else
-    flags = r & ~FD_CLOEXEC;
-
-  do
-    r = fcntl(fd, F_SETFD, flags);
-  while (r == -1 && errno == EINTR);
-
-  if (r)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-ssize_t uv__recvmsg(int fd, struct msghdr* msg, int flags) {
-  struct cmsghdr* cmsg;
-  ssize_t rc;
-  int* pfd;
-  int* end;
-#if defined(__linux__)
-  static int no_msg_cmsg_cloexec;
-  if (no_msg_cmsg_cloexec == 0) {
-    rc = recvmsg(fd, msg, flags | 0x40000000);  /* MSG_CMSG_CLOEXEC */
-    if (rc != -1)
-      return rc;
-    if (errno != EINVAL)
-      return UV__ERR(errno);
-    rc = recvmsg(fd, msg, flags);
-    if (rc == -1)
-      return UV__ERR(errno);
-    no_msg_cmsg_cloexec = 1;
-  } else {
-    rc = recvmsg(fd, msg, flags);
-  }
-#else
-  rc = recvmsg(fd, msg, flags);
-#endif
-  if (rc == -1)
-    return UV__ERR(errno);
-  if (msg->msg_controllen == 0)
-    return rc;
-  for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg))
-    if (cmsg->cmsg_type == SCM_RIGHTS)
-      for (pfd = (int*) CMSG_DATA(cmsg),
-           end = (int*) ((char*) cmsg + cmsg->cmsg_len);
-           pfd < end;
-           pfd += 1)
-        uv__cloexec(*pfd, 1);
-  return rc;
-}
-
-
-int uv_cwd(char* buffer, size_t* size) {
-  char scratch[1 + UV__PATH_MAX];
-
-  if (buffer == NULL || size == NULL)
-    return UV_EINVAL;
-
-  /* Try to read directly into the user's buffer first... */
-  if (getcwd(buffer, *size) != NULL)
-    goto fixup;
-
-  if (errno != ERANGE)
-    return UV__ERR(errno);
-
-  /* ...or into scratch space if the user's buffer is too small
-   * so we can report how much space to provide on the next try.
-   */
-  if (getcwd(scratch, sizeof(scratch)) == NULL)
-    return UV__ERR(errno);
-
-  buffer = scratch;
-
-fixup:
-
-  *size = strlen(buffer);
-
-  if (*size > 1 && buffer[*size - 1] == '/') {
-    *size -= 1;
-    buffer[*size] = '\0';
-  }
-
-  if (buffer == scratch) {
-    *size += 1;
-    return UV_ENOBUFS;
-  }
-
-  return 0;
-}
-
-
-int uv_chdir(const char* dir) {
-  if (chdir(dir))
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-void uv_disable_stdio_inheritance(void) {
-  int fd;
-
-  /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
-   * first 16 file descriptors. After that, bail out after the first error.
-   */
-  for (fd = 0; ; fd++)
-    if (uv__cloexec(fd, 1) && fd > 15)
-      break;
-}
-
-
-int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) {
-  int fd_out;
-
-  switch (handle->type) {
-  case UV_TCP:
-  case UV_NAMED_PIPE:
-  case UV_TTY:
-    fd_out = uv__stream_fd((uv_stream_t*) handle);
-    break;
-
-  case UV_UDP:
-    fd_out = ((uv_udp_t *) handle)->io_watcher.fd;
-    break;
-
-  case UV_POLL:
-    fd_out = ((uv_poll_t *) handle)->io_watcher.fd;
-    break;
-
-  default:
-    return UV_EINVAL;
-  }
-
-  if (uv__is_closing(handle) || fd_out == -1)
-    return UV_EBADF;
-
-  *fd = fd_out;
-  return 0;
-}
-
-
-static int uv__run_pending(uv_loop_t* loop) {
-  QUEUE* q;
-  QUEUE pq;
-  uv__io_t* w;
-
-  if (QUEUE_EMPTY(&loop->pending_queue))
-    return 0;
-
-  QUEUE_MOVE(&loop->pending_queue, &pq);
-
-  while (!QUEUE_EMPTY(&pq)) {
-    q = QUEUE_HEAD(&pq);
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);
-    w = QUEUE_DATA(q, uv__io_t, pending_queue);
-    w->cb(loop, w, POLLOUT);
-  }
-
-  return 1;
-}
-
-
-static unsigned int next_power_of_two(unsigned int val) {
-  val -= 1;
-  val |= val >> 1;
-  val |= val >> 2;
-  val |= val >> 4;
-  val |= val >> 8;
-  val |= val >> 16;
-  val += 1;
-  return val;
-}
-
-static void maybe_resize(uv_loop_t* loop, unsigned int len) {
-  void** watchers;
-  void* fake_watcher_list;
-  void* fake_watcher_count;
-  unsigned int nwatchers;
-  unsigned int i;
-
-  if (len <= loop->nwatchers)
-    return;
-
-  /* Preserve fake watcher list and count at the end of the watchers */
-  if (loop->watchers != NULL) {
-    fake_watcher_list = loop->watchers[loop->nwatchers];
-    fake_watcher_count = loop->watchers[loop->nwatchers + 1];
-  } else {
-    fake_watcher_list = NULL;
-    fake_watcher_count = NULL;
-  }
-
-  nwatchers = next_power_of_two(len + 2) - 2;
-  watchers = (void**)
-      uv__realloc(loop->watchers, (nwatchers + 2) * sizeof(loop->watchers[0]));
-
-  if (watchers == NULL)
-    abort();
-  for (i = loop->nwatchers; i < nwatchers; i++)
-    watchers[i] = NULL;
-  watchers[nwatchers] = fake_watcher_list;
-  watchers[nwatchers + 1] = fake_watcher_count;
-
-  loop->watchers = watchers;
-  loop->nwatchers = nwatchers;
-}
-
-
-void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
-  assert(cb != NULL);
-  assert(fd >= -1);
-  QUEUE_INIT(&w->pending_queue);
-  QUEUE_INIT(&w->watcher_queue);
-  w->cb = cb;
-  w->fd = fd;
-  w->events = 0;
-  w->pevents = 0;
-
-#if defined(UV_HAVE_KQUEUE)
-  w->rcount = 0;
-  w->wcount = 0;
-#endif /* defined(UV_HAVE_KQUEUE) */
-}
-
-
-void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
-  assert(0 != events);
-  assert(w->fd >= 0);
-  assert(w->fd < INT_MAX);
-
-  w->pevents |= events;
-  maybe_resize(loop, w->fd + 1);
-
-#if !defined(__sun)
-  /* The event ports backend needs to rearm all file descriptors on each and
-   * every tick of the event loop but the other backends allow us to
-   * short-circuit here if the event mask is unchanged.
-   */
-  if (w->events == w->pevents)
-    return;
-#endif
-
-  if (QUEUE_EMPTY(&w->watcher_queue))
-    QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
-
-  if (loop->watchers[w->fd] == NULL) {
-    loop->watchers[w->fd] = w;
-    loop->nfds++;
-  }
-}
-
-
-void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
-  assert(0 != events);
-
-  if (w->fd == -1)
-    return;
-
-  assert(w->fd >= 0);
-
-  /* Happens when uv__io_stop() is called on a handle that was never started. */
-  if ((unsigned) w->fd >= loop->nwatchers)
-    return;
-
-  w->pevents &= ~events;
-
-  if (w->pevents == 0) {
-    QUEUE_REMOVE(&w->watcher_queue);
-    QUEUE_INIT(&w->watcher_queue);
-
-    if (loop->watchers[w->fd] != NULL) {
-      assert(loop->watchers[w->fd] == w);
-      assert(loop->nfds > 0);
-      loop->watchers[w->fd] = NULL;
-      loop->nfds--;
-      w->events = 0;
-    }
-  }
-  else if (QUEUE_EMPTY(&w->watcher_queue))
-    QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
-}
-
-
-void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
-  uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
-  QUEUE_REMOVE(&w->pending_queue);
-
-  /* Remove stale events for this file descriptor */
-  if (w->fd != -1)
-    uv__platform_invalidate_fd(loop, w->fd);
-}
-
-
-void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
-  if (QUEUE_EMPTY(&w->pending_queue))
-    QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
-}
-
-
-int uv__io_active(const uv__io_t* w, unsigned int events) {
-  assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
-  assert(0 != events);
-  return 0 != (w->pevents & events);
-}
-
-
-int uv__fd_exists(uv_loop_t* loop, int fd) {
-  return (unsigned) fd < loop->nwatchers && loop->watchers[fd] != NULL;
-}
-
-
-int uv_getrusage(uv_rusage_t* rusage) {
-  struct rusage usage;
-
-  if (getrusage(RUSAGE_SELF, &usage))
-    return UV__ERR(errno);
-
-  rusage->ru_utime.tv_sec = usage.ru_utime.tv_sec;
-  rusage->ru_utime.tv_usec = usage.ru_utime.tv_usec;
-
-  rusage->ru_stime.tv_sec = usage.ru_stime.tv_sec;
-  rusage->ru_stime.tv_usec = usage.ru_stime.tv_usec;
-
-#if !defined(__MVS__) && !defined(__HAIKU__)
-  rusage->ru_maxrss = usage.ru_maxrss;
-  rusage->ru_ixrss = usage.ru_ixrss;
-  rusage->ru_idrss = usage.ru_idrss;
-  rusage->ru_isrss = usage.ru_isrss;
-  rusage->ru_minflt = usage.ru_minflt;
-  rusage->ru_majflt = usage.ru_majflt;
-  rusage->ru_nswap = usage.ru_nswap;
-  rusage->ru_inblock = usage.ru_inblock;
-  rusage->ru_oublock = usage.ru_oublock;
-  rusage->ru_msgsnd = usage.ru_msgsnd;
-  rusage->ru_msgrcv = usage.ru_msgrcv;
-  rusage->ru_nsignals = usage.ru_nsignals;
-  rusage->ru_nvcsw = usage.ru_nvcsw;
-  rusage->ru_nivcsw = usage.ru_nivcsw;
-#endif
-
-  return 0;
-}
-
-
-int uv__open_cloexec(const char* path, int flags) {
-  int err;
-  int fd;
-
-#if defined(UV__O_CLOEXEC)
-  static int no_cloexec;
-
-  if (!no_cloexec) {
-    fd = open(path, flags | UV__O_CLOEXEC);
-    if (fd != -1)
-      return fd;
-
-    if (errno != EINVAL)
-      return UV__ERR(errno);
-
-    /* O_CLOEXEC not supported. */
-    no_cloexec = 1;
-  }
-#endif
-
-  fd = open(path, flags);
-  if (fd == -1)
-    return UV__ERR(errno);
-
-  err = uv__cloexec(fd, 1);
-  if (err) {
-    uv__close(fd);
-    return err;
-  }
-
-  return fd;
-}
-
-
-int uv__dup2_cloexec(int oldfd, int newfd) {
-  int r;
-#if (defined(__FreeBSD__) && __FreeBSD__ >= 10) || defined(__NetBSD__)
-  r = dup3(oldfd, newfd, O_CLOEXEC);
-  if (r == -1)
-    return UV__ERR(errno);
-  return r;
-#elif defined(__FreeBSD__) && defined(F_DUP2FD_CLOEXEC)
-  r = fcntl(oldfd, F_DUP2FD_CLOEXEC, newfd);
-  if (r != -1)
-    return r;
-  if (errno != EINVAL)
-    return UV__ERR(errno);
-  /* Fall through. */
-#elif defined(__linux__)
-  static int no_dup3;
-  if (!no_dup3) {
-    do
-      r = uv__dup3(oldfd, newfd, UV__O_CLOEXEC);
-    while (r == -1 && errno == EBUSY);
-    if (r != -1)
-      return r;
-    if (errno != ENOSYS)
-      return UV__ERR(errno);
-    /* Fall through. */
-    no_dup3 = 1;
-  }
-#endif
-  {
-    int err;
-    do
-      r = dup2(oldfd, newfd);
-#if defined(__linux__)
-    while (r == -1 && errno == EBUSY);
-#else
-    while (0);  /* Never retry. */
-#endif
-
-    if (r == -1)
-      return UV__ERR(errno);
-
-    err = uv__cloexec(newfd, 1);
-    if (err) {
-      uv__close(newfd);
-      return err;
-    }
-
-    return r;
-  }
-}
-
-
-int uv_os_homedir(char* buffer, size_t* size) {
-  uv_passwd_t pwd;
-  size_t len;
-  int r;
-
-  /* Check if the HOME environment variable is set first. The task of
-     performing input validation on buffer and size is taken care of by
-     uv_os_getenv(). */
-  r = uv_os_getenv("HOME", buffer, size);
-
-  if (r != UV_ENOENT)
-    return r;
-
-  /* HOME is not set, so call uv__getpwuid_r() */
-  r = uv__getpwuid_r(&pwd);
-
-  if (r != 0) {
-    return r;
-  }
-
-  len = strlen(pwd.homedir);
-
-  if (len >= *size) {
-    *size = len + 1;
-    uv_os_free_passwd(&pwd);
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, pwd.homedir, len + 1);
-  *size = len;
-  uv_os_free_passwd(&pwd);
-
-  return 0;
-}
-
-
-int uv_os_tmpdir(char* buffer, size_t* size) {
-  const char* buf;
-  size_t len;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-#define CHECK_ENV_VAR(name)                                                   \
-  do {                                                                        \
-    buf = getenv(name);                                                       \
-    if (buf != NULL)                                                          \
-      goto return_buffer;                                                     \
-  }                                                                           \
-  while (0)
-
-  /* Check the TMPDIR, TMP, TEMP, and TEMPDIR environment variables in order */
-  CHECK_ENV_VAR("TMPDIR");
-  CHECK_ENV_VAR("TMP");
-  CHECK_ENV_VAR("TEMP");
-  CHECK_ENV_VAR("TEMPDIR");
-
-#undef CHECK_ENV_VAR
-
-  /* No temp environment variables defined */
-  #if defined(__ANDROID__)
-    buf = "/data/local/tmp";
-  #else
-    buf = "/tmp";
-  #endif
-
-return_buffer:
-  len = strlen(buf);
-
-  if (len >= *size) {
-    *size = len + 1;
-    return UV_ENOBUFS;
-  }
-
-  /* The returned directory should not have a trailing slash. */
-  if (len > 1 && buf[len - 1] == '/') {
-    len--;
-  }
-
-  memcpy(buffer, buf, len + 1);
-  buffer[len] = '\0';
-  *size = len;
-
-  return 0;
-}
-
-
-int uv__getpwuid_r(uv_passwd_t* pwd) {
-  struct passwd pw;
-  struct passwd* result;
-  char* buf;
-  uid_t uid;
-  size_t bufsize;
-  size_t name_size;
-  size_t homedir_size;
-  size_t shell_size;
-  long initsize;
-  int r;
-#if defined(__ANDROID_API__) && __ANDROID_API__ < 21
-  int (*getpwuid_r)(uid_t, struct passwd*, char*, size_t, struct passwd**);
-
-  getpwuid_r = dlsym(RTLD_DEFAULT, "getpwuid_r");
-  if (getpwuid_r == NULL)
-    return UV_ENOSYS;
-#endif
-
-  if (pwd == NULL)
-    return UV_EINVAL;
-
-  initsize = sysconf(_SC_GETPW_R_SIZE_MAX);
-
-  if (initsize <= 0)
-    bufsize = 4096;
-  else
-    bufsize = (size_t) initsize;
-
-  uid = geteuid();
-  buf = NULL;
-
-  for (;;) {
-    uv__free(buf);
-    buf = (char*)uv__malloc(bufsize);
-
-    if (buf == NULL)
-      return UV_ENOMEM;
-
-    r = getpwuid_r(uid, &pw, buf, bufsize, &result);
-
-    if (r != ERANGE)
-      break;
-
-    bufsize *= 2;
-  }
-
-  if (r != 0) {
-    uv__free(buf);
-    return -r;
-  }
-
-  if (result == NULL) {
-    uv__free(buf);
-    return UV_ENOENT;
-  }
-
-  /* Allocate memory for the username, shell, and home directory */
-  name_size = strlen(pw.pw_name) + 1;
-  homedir_size = strlen(pw.pw_dir) + 1;
-  shell_size = strlen(pw.pw_shell) + 1;
-  pwd->username = (char*)uv__malloc(name_size + homedir_size + shell_size);
-
-  if (pwd->username == NULL) {
-    uv__free(buf);
-    return UV_ENOMEM;
-  }
-
-  /* Copy the username */
-  memcpy(pwd->username, pw.pw_name, name_size);
-
-  /* Copy the home directory */
-  pwd->homedir = pwd->username + name_size;
-  memcpy(pwd->homedir, pw.pw_dir, homedir_size);
-
-  /* Copy the shell */
-  pwd->shell = pwd->homedir + homedir_size;
-  memcpy(pwd->shell, pw.pw_shell, shell_size);
-
-  /* Copy the uid and gid */
-  pwd->uid = pw.pw_uid;
-  pwd->gid = pw.pw_gid;
-
-  uv__free(buf);
-
-  return 0;
-}
-
-
-void uv_os_free_passwd(uv_passwd_t* pwd) {
-  if (pwd == NULL)
-    return;
-
-  /*
-    The memory for name, shell, and homedir are allocated in a single
-    uv__malloc() call. The base of the pointer is stored in pwd->username, so
-    that is the field that needs to be freed.
-  */
-  uv__free(pwd->username);
-  pwd->username = NULL;
-  pwd->shell = NULL;
-  pwd->homedir = NULL;
-}
-
-
-int uv_os_get_passwd(uv_passwd_t* pwd) {
-  return uv__getpwuid_r(pwd);
-}
-
-
-int uv_translate_sys_error(int sys_errno) {
-  /* If < 0 then it's already a libuv error. */
-  return sys_errno <= 0 ? sys_errno : -sys_errno;
-}
-
-
-int uv_os_getenv(const char* name, char* buffer, size_t* size) {
-  char* var;
-  size_t len;
-
-  if (name == NULL || buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  var = getenv(name);
-
-  if (var == NULL)
-    return UV_ENOENT;
-
-  len = strlen(var);
-
-  if (len >= *size) {
-    *size = len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, var, len + 1);
-  *size = len;
-
-  return 0;
-}
-
-
-int uv_os_setenv(const char* name, const char* value) {
-  if (name == NULL || value == NULL)
-    return UV_EINVAL;
-
-  if (setenv(name, value, 1) != 0)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-int uv_os_unsetenv(const char* name) {
-  if (name == NULL)
-    return UV_EINVAL;
-
-  if (unsetenv(name) != 0)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-int uv_os_gethostname(char* buffer, size_t* size) {
-  /*
-    On some platforms, if the input buffer is not large enough, gethostname()
-    succeeds, but truncates the result. libuv can detect this and return ENOBUFS
-    instead by creating a large enough buffer and comparing the hostname length
-    to the size input.
-  */
-  char buf[UV_MAXHOSTNAMESIZE];
-  size_t len;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  if (gethostname(buf, sizeof(buf)) != 0)
-    return UV__ERR(errno);
-
-  buf[sizeof(buf) - 1] = '\0'; /* Null terminate, just to be safe. */
-  len = strlen(buf);
-
-  if (len >= *size) {
-    *size = len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, buf, len + 1);
-  *size = len;
-  return 0;
-}
-
-
-uv_os_fd_t uv_get_osfhandle(int fd) {
-  return fd;
-}
-
-int uv_open_osfhandle(uv_os_fd_t os_fd) {
-  return os_fd;
-}
-
-uv_pid_t uv_os_getpid(void) {
-  return getpid();
-}
-
-
-uv_pid_t uv_os_getppid(void) {
-  return getppid();
-}
-
-
-int uv_os_getpriority(uv_pid_t pid, int* priority) {
-  int r;
-
-  if (priority == NULL)
-    return UV_EINVAL;
-
-  errno = 0;
-  r = getpriority(PRIO_PROCESS, (int) pid);
-
-  if (r == -1 && errno != 0)
-    return UV__ERR(errno);
-
-  *priority = r;
-  return 0;
-}
-
-
-int uv_os_setpriority(uv_pid_t pid, int priority) {
-  if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW)
-    return UV_EINVAL;
-
-  if (setpriority(PRIO_PROCESS, (int) pid, priority) != 0)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-int uv_os_uname(uv_utsname_t* buffer) {
-  struct utsname buf;
-  int r;
-
-  if (buffer == NULL)
-    return UV_EINVAL;
-
-  if (uname(&buf) == -1) {
-    r = UV__ERR(errno);
-    goto error;
-  }
-
-  r = uv__strscpy(buffer->sysname, buf.sysname, sizeof(buffer->sysname));
-  if (r == UV_E2BIG)
-    goto error;
-
-#ifdef _AIX
-  r = snprintf(buffer->release,
-               sizeof(buffer->release),
-               "%s.%s",
-               buf.version,
-               buf.release);
-  if (r >= sizeof(buffer->release)) {
-    r = UV_E2BIG;
-    goto error;
-  }
-#else
-  r = uv__strscpy(buffer->release, buf.release, sizeof(buffer->release));
-  if (r == UV_E2BIG)
-    goto error;
-#endif
-
-  r = uv__strscpy(buffer->version, buf.version, sizeof(buffer->version));
-  if (r == UV_E2BIG)
-    goto error;
-
-#if defined(_AIX) || defined(__PASE__)
-  r = uv__strscpy(buffer->machine, "ppc64", sizeof(buffer->machine));
-#else
-  r = uv__strscpy(buffer->machine, buf.machine, sizeof(buffer->machine));
-#endif
-
-  if (r == UV_E2BIG)
-    goto error;
-
-  return 0;
-
-error:
-  buffer->sysname[0] = '\0';
-  buffer->release[0] = '\0';
-  buffer->version[0] = '\0';
-  buffer->machine[0] = '\0';
-  return r;
-}
-
-int uv__getsockpeername(const uv_handle_t* handle,
-                        uv__peersockfunc func,
-                        struct sockaddr* name,
-                        int* namelen) {
-  socklen_t socklen;
-  uv_os_fd_t fd;
-  int r;
-
-  r = uv_fileno(handle, &fd);
-  if (r < 0)
-    return r;
-
-  /* sizeof(socklen_t) != sizeof(int) on some systems. */
-  socklen = (socklen_t) *namelen;
-
-  if (func(fd, name, &socklen))
-    return UV__ERR(errno);
-
-  *namelen = (int) socklen;
-  return 0;
-}
-
-int uv_gettimeofday(uv_timeval64_t* tv) {
-  struct timeval time;
-
-  if (tv == NULL)
-    return UV_EINVAL;
-
-  if (gettimeofday(&time, NULL) != 0)
-    return UV__ERR(errno);
-
-  tv->tv_sec = (int64_t) time.tv_sec;
-  tv->tv_usec = (int32_t) time.tv_usec;
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/cygwin.cpp b/wpiutil/src/main/native/libuv/src/unix/cygwin.cpp
deleted file mode 100644
index 6b5cfb7..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/cygwin.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <sys/sysinfo.h>
-#include <unistd.h>
-
-int uv_uptime(double* uptime) {
-  struct sysinfo info;
-
-  if (sysinfo(&info) < 0)
-    return UV__ERR(errno);
-
-  *uptime = info.uptime;
-  return 0;
-}
-
-int uv_resident_set_memory(size_t* rss) {
-  /* FIXME: read /proc/meminfo? */
-  *rss = 0;
-  return 0;
-}
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  /* FIXME: read /proc/stat? */
-  *cpu_infos = NULL;
-  *count = 0;
-  return UV_ENOSYS;
-}
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  (void)cpu_infos;
-  (void)count;
-}
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/darwin-proctitle.cpp b/wpiutil/src/main/native/libuv/src/unix/darwin-proctitle.cpp
deleted file mode 100644
index f05d9f9..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/darwin-proctitle.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <dlfcn.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <TargetConditionals.h>
-
-#if !TARGET_OS_IPHONE
-# include <CoreFoundation/CoreFoundation.h>
-# include <ApplicationServices/ApplicationServices.h>
-#endif
-
-#define S(s) pCFStringCreateWithCString(NULL, (s), kCFStringEncodingUTF8)
-
-
-static int (*dynamic_pthread_setname_np)(const char* name);
-#if !TARGET_OS_IPHONE
-static CFStringRef (*pCFStringCreateWithCString)(CFAllocatorRef,
-                                                 const char*,
-                                                 CFStringEncoding);
-static CFBundleRef (*pCFBundleGetBundleWithIdentifier)(CFStringRef);
-static void *(*pCFBundleGetDataPointerForName)(CFBundleRef, CFStringRef);
-static void *(*pCFBundleGetFunctionPointerForName)(CFBundleRef, CFStringRef);
-static CFTypeRef (*pLSGetCurrentApplicationASN)(void);
-static OSStatus (*pLSSetApplicationInformationItem)(int,
-                                                    CFTypeRef,
-                                                    CFStringRef,
-                                                    CFStringRef,
-                                                    CFDictionaryRef*);
-static void* application_services_handle;
-static void* core_foundation_handle;
-static CFBundleRef launch_services_bundle;
-static CFStringRef* display_name_key;
-static CFDictionaryRef (*pCFBundleGetInfoDictionary)(CFBundleRef);
-static CFBundleRef (*pCFBundleGetMainBundle)(void);
-static CFBundleRef hi_services_bundle;
-static OSStatus (*pSetApplicationIsDaemon)(int);
-static CFDictionaryRef (*pLSApplicationCheckIn)(int, CFDictionaryRef);
-static void (*pLSSetApplicationLaunchServicesServerConnectionStatus)(uint64_t,
-                                                                     void*);
-
-
-UV_DESTRUCTOR(static void uv__set_process_title_platform_fini(void)) {
-  if (core_foundation_handle != NULL) {
-    dlclose(core_foundation_handle);
-    core_foundation_handle = NULL;
-  }
-
-  if (application_services_handle != NULL) {
-    dlclose(application_services_handle);
-    application_services_handle = NULL;
-  }
-}
-#endif  /* !TARGET_OS_IPHONE */
-
-
-void uv__set_process_title_platform_init(void) {
-  /* pthread_setname_np() first appeared in OS X 10.6 and iOS 3.2. */
-  *(void **)(&dynamic_pthread_setname_np) =
-      dlsym(RTLD_DEFAULT, "pthread_setname_np");
-
-#if !TARGET_OS_IPHONE
-  application_services_handle = dlopen("/System/Library/Frameworks/"
-                                       "ApplicationServices.framework/"
-                                       "Versions/A/ApplicationServices",
-                                       RTLD_LAZY | RTLD_LOCAL);
-  core_foundation_handle = dlopen("/System/Library/Frameworks/"
-                                  "CoreFoundation.framework/"
-                                  "Versions/A/CoreFoundation",
-                                  RTLD_LAZY | RTLD_LOCAL);
-
-  if (application_services_handle == NULL || core_foundation_handle == NULL)
-    goto out;
-
-  *(void **)(&pCFStringCreateWithCString) =
-      dlsym(core_foundation_handle, "CFStringCreateWithCString");
-  *(void **)(&pCFBundleGetBundleWithIdentifier) =
-      dlsym(core_foundation_handle, "CFBundleGetBundleWithIdentifier");
-  *(void **)(&pCFBundleGetDataPointerForName) =
-      dlsym(core_foundation_handle, "CFBundleGetDataPointerForName");
-  *(void **)(&pCFBundleGetFunctionPointerForName) =
-      dlsym(core_foundation_handle, "CFBundleGetFunctionPointerForName");
-
-  if (pCFStringCreateWithCString == NULL ||
-      pCFBundleGetBundleWithIdentifier == NULL ||
-      pCFBundleGetDataPointerForName == NULL ||
-      pCFBundleGetFunctionPointerForName == NULL) {
-    goto out;
-  }
-
-  launch_services_bundle =
-      pCFBundleGetBundleWithIdentifier(S("com.apple.LaunchServices"));
-
-  if (launch_services_bundle == NULL)
-    goto out;
-
-  *(void **)(&pLSGetCurrentApplicationASN) =
-      pCFBundleGetFunctionPointerForName(launch_services_bundle,
-                                         S("_LSGetCurrentApplicationASN"));
-
-  if (pLSGetCurrentApplicationASN == NULL)
-    goto out;
-
-  *(void **)(&pLSSetApplicationInformationItem) =
-      pCFBundleGetFunctionPointerForName(launch_services_bundle,
-                                         S("_LSSetApplicationInformationItem"));
-
-  if (pLSSetApplicationInformationItem == NULL)
-    goto out;
-
-  display_name_key = (CFStringRef*)
-      pCFBundleGetDataPointerForName(launch_services_bundle,
-                                     S("_kLSDisplayNameKey"));
-
-  if (display_name_key == NULL || *display_name_key == NULL)
-    goto out;
-
-  *(void **)(&pCFBundleGetInfoDictionary) = dlsym(core_foundation_handle,
-                                     "CFBundleGetInfoDictionary");
-  *(void **)(&pCFBundleGetMainBundle) = dlsym(core_foundation_handle,
-                                 "CFBundleGetMainBundle");
-
-  if (pCFBundleGetInfoDictionary == NULL || pCFBundleGetMainBundle == NULL)
-    goto out;
-
-  /* Black 10.9 magic, to remove (Not responding) mark in Activity Monitor */
-  hi_services_bundle =
-      pCFBundleGetBundleWithIdentifier(S("com.apple.HIServices"));
-
-  if (hi_services_bundle == NULL)
-    goto out;
-
-  *(void **)(&pSetApplicationIsDaemon) = pCFBundleGetFunctionPointerForName(
-      hi_services_bundle,
-      S("SetApplicationIsDaemon"));
-  *(void **)(&pLSApplicationCheckIn) = pCFBundleGetFunctionPointerForName(
-      launch_services_bundle,
-      S("_LSApplicationCheckIn"));
-  *(void **)(&pLSSetApplicationLaunchServicesServerConnectionStatus) =
-      pCFBundleGetFunctionPointerForName(
-          launch_services_bundle,
-          S("_LSSetApplicationLaunchServicesServerConnectionStatus"));
-
-  if (pSetApplicationIsDaemon == NULL ||
-      pLSApplicationCheckIn == NULL ||
-      pLSSetApplicationLaunchServicesServerConnectionStatus == NULL) {
-    goto out;
-  }
-
-  return;
-
-out:
-  uv__set_process_title_platform_fini();
-#endif  /* !TARGET_OS_IPHONE */
-}
-
-
-void uv__set_process_title(const char* title) {
-#if !TARGET_OS_IPHONE
-  if (core_foundation_handle != NULL && pSetApplicationIsDaemon(1) != noErr) {
-    CFTypeRef asn;
-    pLSSetApplicationLaunchServicesServerConnectionStatus(0, NULL);
-    pLSApplicationCheckIn(/* Magic value */ -2,
-                          pCFBundleGetInfoDictionary(pCFBundleGetMainBundle()));
-    asn = pLSGetCurrentApplicationASN();
-    pLSSetApplicationInformationItem(/* Magic value */ -2, asn,
-                                     *display_name_key, S(title), NULL);
-  }
-#endif  /* !TARGET_OS_IPHONE */
-
-  if (dynamic_pthread_setname_np != NULL) {
-    char namebuf[64];  /* MAXTHREADNAMESIZE */
-    uv__strscpy(namebuf, title, sizeof(namebuf));
-    dynamic_pthread_setname_np(namebuf);
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/darwin.cpp b/wpiutil/src/main/native/libuv/src/unix/darwin.cpp
deleted file mode 100644
index 2282d91..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/darwin.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <stdint.h>
-#include <errno.h>
-
-#include <mach/mach.h>
-#include <mach/mach_time.h>
-#include <mach-o/dyld.h> /* _NSGetExecutablePath */
-#include <sys/resource.h>
-#include <sys/sysctl.h>
-#include <unistd.h>  /* sysconf */
-
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  loop->cf_state = NULL;
-
-  if (uv__kqueue_init(loop))
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-  uv__fsevents_loop_delete(loop);
-}
-
-
-uint64_t uv__hrtime(uv_clocktype_t type) {
-  static mach_timebase_info_data_t info;
-
-  if ((ACCESS_ONCE(uint32_t, info.numer) == 0 ||
-       ACCESS_ONCE(uint32_t, info.denom) == 0) &&
-      mach_timebase_info(&info) != KERN_SUCCESS)
-    abort();
-
-  return mach_absolute_time() * info.numer / info.denom;
-}
-
-
-int uv_exepath(char* buffer, size_t* size) {
-  /* realpath(exepath) may be > PATH_MAX so double it to be on the safe side. */
-  char abspath[PATH_MAX * 2 + 1];
-  char exepath[PATH_MAX + 1];
-  uint32_t exepath_size;
-  size_t abspath_size;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  exepath_size = sizeof(exepath);
-  if (_NSGetExecutablePath(exepath, &exepath_size))
-    return UV_EIO;
-
-  if (realpath(exepath, abspath) != abspath)
-    return UV__ERR(errno);
-
-  abspath_size = strlen(abspath);
-  if (abspath_size == 0)
-    return UV_EIO;
-
-  *size -= 1;
-  if (*size > abspath_size)
-    *size = abspath_size;
-
-  memcpy(buffer, abspath, *size);
-  buffer[*size] = '\0';
-
-  return 0;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  vm_statistics_data_t info;
-  mach_msg_type_number_t count = sizeof(info) / sizeof(integer_t);
-
-  if (host_statistics(mach_host_self(), HOST_VM_INFO,
-                      (host_info_t)&info, &count) != KERN_SUCCESS) {
-    return UV_EINVAL;  /* FIXME(bnoordhuis) Translate error. */
-  }
-
-  return (uint64_t) info.free_count * sysconf(_SC_PAGESIZE);
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  uint64_t info;
-  int which[] = {CTL_HW, HW_MEMSIZE};
-  size_t size = sizeof(info);
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-void uv_loadavg(double avg[3]) {
-  struct loadavg info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_LOADAVG};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0) < 0) return;
-
-  avg[0] = (double) info.ldavg[0] / info.fscale;
-  avg[1] = (double) info.ldavg[1] / info.fscale;
-  avg[2] = (double) info.ldavg[2] / info.fscale;
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  mach_msg_type_number_t count;
-  task_basic_info_data_t info;
-  kern_return_t err;
-
-  count = TASK_BASIC_INFO_COUNT;
-  err = task_info(mach_task_self(),
-                  TASK_BASIC_INFO,
-                  (task_info_t) &info,
-                  &count);
-  (void) &err;
-  /* task_info(TASK_BASIC_INFO) cannot really fail. Anything other than
-   * KERN_SUCCESS implies a libuv bug.
-   */
-  assert(err == KERN_SUCCESS);
-  *rss = info.resident_size;
-
-  return 0;
-}
-
-
-int uv_uptime(double* uptime) {
-  time_t now;
-  struct timeval info;
-  size_t size = sizeof(info);
-  static int which[] = {CTL_KERN, KERN_BOOTTIME};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  now = time(NULL);
-  *uptime = now - info.tv_sec;
-
-  return 0;
-}
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),
-               multiplier = ((uint64_t)1000L / ticks);
-  char model[512];
-  uint64_t cpuspeed;
-  size_t size;
-  unsigned int i;
-  natural_t numcpus;
-  mach_msg_type_number_t msg_type;
-  processor_cpu_load_info_data_t *info;
-  uv_cpu_info_t* cpu_info;
-
-  size = sizeof(model);
-  if (sysctlbyname("machdep.cpu.brand_string", &model, &size, NULL, 0) &&
-      sysctlbyname("hw.model", &model, &size, NULL, 0)) {
-    return UV__ERR(errno);
-  }
-
-  size = sizeof(cpuspeed);
-  if (sysctlbyname("hw.cpufrequency", &cpuspeed, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numcpus,
-                          (processor_info_array_t*)&info,
-                          &msg_type) != KERN_SUCCESS) {
-    return UV_EINVAL;  /* FIXME(bnoordhuis) Translate error. */
-  }
-
-  *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos));
-  if (!(*cpu_infos)) {
-    vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type);
-    return UV_ENOMEM;
-  }
-
-  *count = numcpus;
-
-  for (i = 0; i < numcpus; i++) {
-    cpu_info = &(*cpu_infos)[i];
-
-    cpu_info->cpu_times.user = (uint64_t)(info[i].cpu_ticks[0]) * multiplier;
-    cpu_info->cpu_times.nice = (uint64_t)(info[i].cpu_ticks[3]) * multiplier;
-    cpu_info->cpu_times.sys = (uint64_t)(info[i].cpu_ticks[1]) * multiplier;
-    cpu_info->cpu_times.idle = (uint64_t)(info[i].cpu_ticks[2]) * multiplier;
-    cpu_info->cpu_times.irq = 0;
-
-    cpu_info->model = uv__strdup(model);
-    cpu_info->speed = cpuspeed/1000000;
-  }
-  vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type);
-
-  return 0;
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/dl.cpp b/wpiutil/src/main/native/libuv/src/unix/dl.cpp
deleted file mode 100644
index fc1c052..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/dl.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <dlfcn.h>
-#include <errno.h>
-#include <string.h>
-#include <locale.h>
-
-static int uv__dlerror(uv_lib_t* lib);
-
-
-int uv_dlopen(const char* filename, uv_lib_t* lib) {
-  dlerror(); /* Reset error status. */
-  lib->errmsg = NULL;
-  lib->handle = dlopen(filename, RTLD_LAZY);
-  return lib->handle ? 0 : uv__dlerror(lib);
-}
-
-
-void uv_dlclose(uv_lib_t* lib) {
-  uv__free(lib->errmsg);
-  lib->errmsg = NULL;
-
-  if (lib->handle) {
-    /* Ignore errors. No good way to signal them without leaking memory. */
-    dlclose(lib->handle);
-    lib->handle = NULL;
-  }
-}
-
-
-int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr) {
-  dlerror(); /* Reset error status. */
-  *ptr = dlsym(lib->handle, name);
-  return uv__dlerror(lib);
-}
-
-
-const char* uv_dlerror(const uv_lib_t* lib) {
-  return lib->errmsg ? lib->errmsg : "no error";
-}
-
-
-static int uv__dlerror(uv_lib_t* lib) {
-  const char* errmsg;
-
-  uv__free(lib->errmsg);
-
-  errmsg = dlerror();
-
-  if (errmsg) {
-    lib->errmsg = uv__strdup(errmsg);
-    return -1;
-  }
-  else {
-    lib->errmsg = NULL;
-    return 0;
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/freebsd.cpp b/wpiutil/src/main/native/libuv/src/unix/freebsd.cpp
deleted file mode 100644
index c401145..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/freebsd.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <string.h>
-#include <errno.h>
-
-#include <paths.h>
-#include <sys/user.h>
-#include <sys/types.h>
-#include <sys/resource.h>
-#include <sys/sysctl.h>
-#include <vm/vm_param.h> /* VM_LOADAVG */
-#include <time.h>
-#include <stdlib.h>
-#include <unistd.h> /* sysconf */
-#include <fcntl.h>
-
-#ifndef CPUSTATES
-# define CPUSTATES 5U
-#endif
-#ifndef CP_USER
-# define CP_USER 0
-# define CP_NICE 1
-# define CP_SYS 2
-# define CP_IDLE 3
-# define CP_INTR 4
-#endif
-
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  return uv__kqueue_init(loop);
-}
-
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-}
-
-
-#ifdef __DragonFly__
-int uv_exepath(char* buffer, size_t* size) {
-  char abspath[PATH_MAX * 2 + 1];
-  ssize_t abspath_size;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  abspath_size = readlink("/proc/curproc/file", abspath, sizeof(abspath));
-  if (abspath_size < 0)
-    return UV__ERR(errno);
-
-  assert(abspath_size > 0);
-  *size -= 1;
-
-  if (*size > abspath_size)
-    *size = abspath_size;
-
-  memcpy(buffer, abspath, *size);
-  buffer[*size] = '\0';
-
-  return 0;
-}
-#else
-int uv_exepath(char* buffer, size_t* size) {
-  char abspath[PATH_MAX * 2 + 1];
-  int mib[4];
-  size_t abspath_size;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  mib[0] = CTL_KERN;
-  mib[1] = KERN_PROC;
-  mib[2] = KERN_PROC_PATHNAME;
-  mib[3] = -1;
-
-  abspath_size = sizeof abspath;
-  if (sysctl(mib, 4, abspath, &abspath_size, NULL, 0))
-    return UV__ERR(errno);
-
-  assert(abspath_size > 0);
-  abspath_size -= 1;
-  *size -= 1;
-
-  if (*size > abspath_size)
-    *size = abspath_size;
-
-  memcpy(buffer, abspath, *size);
-  buffer[*size] = '\0';
-
-  return 0;
-}
-#endif
-
-uint64_t uv_get_free_memory(void) {
-  int freecount;
-  size_t size = sizeof(freecount);
-
-  if (sysctlbyname("vm.stats.vm.v_free_count", &freecount, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) freecount * sysconf(_SC_PAGESIZE);
-
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  unsigned long info;
-  int which[] = {CTL_HW, HW_PHYSMEM};
-
-  size_t size = sizeof(info);
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-void uv_loadavg(double avg[3]) {
-  struct loadavg info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_LOADAVG};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0) < 0) return;
-
-  avg[0] = (double) info.ldavg[0] / info.fscale;
-  avg[1] = (double) info.ldavg[1] / info.fscale;
-  avg[2] = (double) info.ldavg[2] / info.fscale;
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  struct kinfo_proc kinfo;
-  size_t page_size;
-  size_t kinfo_size;
-  int mib[4];
-
-  mib[0] = CTL_KERN;
-  mib[1] = KERN_PROC;
-  mib[2] = KERN_PROC_PID;
-  mib[3] = getpid();
-
-  kinfo_size = sizeof(kinfo);
-
-  if (sysctl(mib, 4, &kinfo, &kinfo_size, NULL, 0))
-    return UV__ERR(errno);
-
-  page_size = getpagesize();
-
-#ifdef __DragonFly__
-  *rss = kinfo.kp_vm_rssize * page_size;
-#else
-  *rss = kinfo.ki_rssize * page_size;
-#endif
-
-  return 0;
-}
-
-
-int uv_uptime(double* uptime) {
-  int r;
-  struct timespec sp;
-  r = clock_gettime(CLOCK_MONOTONIC, &sp);
-  if (r)
-    return UV__ERR(errno);
-
-  *uptime = sp.tv_sec;
-  return 0;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),
-               multiplier = ((uint64_t)1000L / ticks), cpuspeed, maxcpus,
-               cur = 0;
-  uv_cpu_info_t* cpu_info;
-  const char* maxcpus_key;
-  const char* cptimes_key;
-  const char* model_key;
-  char model[512];
-  long* cp_times;
-  int numcpus;
-  size_t size;
-  int i;
-
-#if defined(__DragonFly__)
-  /* This is not quite correct but DragonFlyBSD doesn't seem to have anything
-   * comparable to kern.smp.maxcpus or kern.cp_times (kern.cp_time is a total,
-   * not per CPU). At least this stops uv_cpu_info() from failing completely.
-   */
-  maxcpus_key = "hw.ncpu";
-  cptimes_key = "kern.cp_time";
-#else
-  maxcpus_key = "kern.smp.maxcpus";
-  cptimes_key = "kern.cp_times";
-#endif
-
-#if defined(__arm__) || defined(__aarch64__)
-  /* The key hw.model and hw.clockrate are not available on FreeBSD ARM. */
-  model_key = "hw.machine";
-  cpuspeed = 0;
-#else
-  model_key = "hw.model";
-
-  size = sizeof(cpuspeed);
-  if (sysctlbyname("hw.clockrate", &cpuspeed, &size, NULL, 0))
-    return -errno;
-#endif
-
-  size = sizeof(model);
-  if (sysctlbyname(model_key, &model, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  size = sizeof(numcpus);
-  if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos));
-  if (!(*cpu_infos))
-    return UV_ENOMEM;
-
-  *count = numcpus;
-
-  /* kern.cp_times on FreeBSD i386 gives an array up to maxcpus instead of
-   * ncpu.
-   */
-  size = sizeof(maxcpus);
-  if (sysctlbyname(maxcpus_key, &maxcpus, &size, NULL, 0)) {
-    uv__free(*cpu_infos);
-    return UV__ERR(errno);
-  }
-
-  size = maxcpus * CPUSTATES * sizeof(long);
-
-  cp_times = (long*)uv__malloc(size);
-  if (cp_times == NULL) {
-    uv__free(*cpu_infos);
-    return UV_ENOMEM;
-  }
-
-  if (sysctlbyname(cptimes_key, cp_times, &size, NULL, 0)) {
-    uv__free(cp_times);
-    uv__free(*cpu_infos);
-    return UV__ERR(errno);
-  }
-
-  for (i = 0; i < numcpus; i++) {
-    cpu_info = &(*cpu_infos)[i];
-
-    cpu_info->cpu_times.user = (uint64_t)(cp_times[CP_USER+cur]) * multiplier;
-    cpu_info->cpu_times.nice = (uint64_t)(cp_times[CP_NICE+cur]) * multiplier;
-    cpu_info->cpu_times.sys = (uint64_t)(cp_times[CP_SYS+cur]) * multiplier;
-    cpu_info->cpu_times.idle = (uint64_t)(cp_times[CP_IDLE+cur]) * multiplier;
-    cpu_info->cpu_times.irq = (uint64_t)(cp_times[CP_INTR+cur]) * multiplier;
-
-    cpu_info->model = uv__strdup(model);
-    cpu_info->speed = cpuspeed;
-
-    cur+=CPUSTATES;
-  }
-
-  uv__free(cp_times);
-  return 0;
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/fs.cpp b/wpiutil/src/main/native/libuv/src/unix/fs.cpp
deleted file mode 100644
index 36871ee..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/fs.cpp
+++ /dev/null
@@ -1,1860 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-/* Caveat emptor: this file deviates from the libuv convention of returning
- * negated errno codes. Most uv_fs_*() functions map directly to the system
- * call of the same name. For more complex wrappers, it's easier to just
- * return -1 with errno set. The dispatcher in uv__fs_work() takes care of
- * getting the errno to the right place (req->result or as the return value.)
- */
-
-#include "uv.h"
-#include "internal.h"
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h> /* PATH_MAX */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <poll.h>
-
-#if defined(__DragonFly__)        ||                                      \
-    defined(__FreeBSD__)          ||                                      \
-    defined(__FreeBSD_kernel__)   ||                                      \
-    defined(__OpenBSD__)          ||                                      \
-    defined(__NetBSD__)
-# define HAVE_PREADV 1
-#else
-# define HAVE_PREADV 0
-#endif
-
-#if defined(__linux__) || defined(__sun)
-# include <sys/sendfile.h>
-#endif
-
-#if defined(__APPLE__)
-# include <sys/sysctl.h>
-#elif defined(__linux__) && !defined(FICLONE)
-# include <sys/ioctl.h>
-# define FICLONE _IOW(0x94, 9, int)
-#endif
-
-#if defined(_AIX) && !defined(_AIX71)
-# include <utime.h>
-#endif
-
-#if defined(_AIX) && _XOPEN_SOURCE <= 600
-extern char *mkdtemp(char *template); /* See issue #740 on AIX < 7 */
-#endif
-
-#define INIT(subtype)                                                         \
-  do {                                                                        \
-    if (req == NULL)                                                          \
-      return UV_EINVAL;                                                       \
-    UV_REQ_INIT(req, UV_FS);                                                  \
-    req->fs_type = UV_FS_ ## subtype;                                         \
-    req->result = 0;                                                          \
-    req->ptr = NULL;                                                          \
-    req->loop = loop;                                                         \
-    req->path = NULL;                                                         \
-    req->new_path = NULL;                                                     \
-    req->bufs = NULL;                                                         \
-    req->cb = cb;                                                             \
-  }                                                                           \
-  while (0)
-
-#define PATH                                                                  \
-  do {                                                                        \
-    assert(path != NULL);                                                     \
-    if (cb == NULL) {                                                         \
-      req->path = path;                                                       \
-    } else {                                                                  \
-      req->path = uv__strdup(path);                                           \
-      if (req->path == NULL)                                                  \
-        return UV_ENOMEM;                                                     \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-#define PATH2                                                                 \
-  do {                                                                        \
-    if (cb == NULL) {                                                         \
-      req->path = path;                                                       \
-      req->new_path = new_path;                                               \
-    } else {                                                                  \
-      size_t path_len;                                                        \
-      size_t new_path_len;                                                    \
-      path_len = strlen(path) + 1;                                            \
-      new_path_len = strlen(new_path) + 1;                                    \
-      req->path = (char*)uv__malloc(path_len + new_path_len);                 \
-      if (req->path == NULL)                                                  \
-        return UV_ENOMEM;                                                     \
-      req->new_path = req->path + path_len;                                   \
-      memcpy((void*) req->path, path, path_len);                              \
-      memcpy((void*) req->new_path, new_path, new_path_len);                  \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-#define POST                                                                  \
-  do {                                                                        \
-    if (cb != NULL) {                                                         \
-      uv__req_register(loop, req);                                            \
-      uv__work_submit(loop,                                                   \
-                      &req->work_req,                                         \
-                      UV__WORK_FAST_IO,                                       \
-                      uv__fs_work,                                            \
-                      uv__fs_done);                                           \
-      return 0;                                                               \
-    }                                                                         \
-    else {                                                                    \
-      uv__fs_work(&req->work_req);                                            \
-      return req->result;                                                     \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-
-static int uv__fs_close(int fd) {
-  int rc;
-
-  rc = uv__close_nocancel(fd);
-  if (rc == -1)
-    if (errno == EINTR || errno == EINPROGRESS)
-      rc = 0;  /* The close is in progress, not an error. */
-
-  return rc;
-}
-
-
-static ssize_t uv__fs_fsync(uv_fs_t* req) {
-#if defined(__APPLE__)
-  /* Apple's fdatasync and fsync explicitly do NOT flush the drive write cache
-   * to the drive platters. This is in contrast to Linux's fdatasync and fsync
-   * which do, according to recent man pages. F_FULLFSYNC is Apple's equivalent
-   * for flushing buffered data to permanent storage. If F_FULLFSYNC is not
-   * supported by the file system we fall back to F_BARRIERFSYNC or fsync().
-   * This is the same approach taken by sqlite, except sqlite does not issue
-   * an F_BARRIERFSYNC call.
-   */
-  int r;
-
-  r = fcntl(req->file, F_FULLFSYNC);
-  if (r != 0)
-    r = fcntl(req->file, 85 /* F_BARRIERFSYNC */);  /* fsync + barrier */
-  if (r != 0)
-    r = fsync(req->file);
-  return r;
-#else
-  return fsync(req->file);
-#endif
-}
-
-
-static ssize_t uv__fs_fdatasync(uv_fs_t* req) {
-#if defined(__linux__) || defined(__sun) || defined(__NetBSD__)
-  return fdatasync(req->file);
-#elif defined(__APPLE__)
-  /* See the comment in uv__fs_fsync. */
-  return uv__fs_fsync(req);
-#else
-  return fsync(req->file);
-#endif
-}
-
-
-static ssize_t uv__fs_futime(uv_fs_t* req) {
-#if defined(__linux__)                                                        \
-    || defined(_AIX71)                                                        \
-    || defined(__HAIKU__)
-  /* utimesat() has nanosecond resolution but we stick to microseconds
-   * for the sake of consistency with other platforms.
-   */
-  struct timespec ts[2];
-  ts[0].tv_sec  = req->atime;
-  ts[0].tv_nsec = (uint64_t)(req->atime * 1000000) % 1000000 * 1000;
-  ts[1].tv_sec  = req->mtime;
-  ts[1].tv_nsec = (uint64_t)(req->mtime * 1000000) % 1000000 * 1000;
-  return futimens(req->file, ts);
-#elif defined(__APPLE__)                                                      \
-    || defined(__DragonFly__)                                                 \
-    || defined(__FreeBSD__)                                                   \
-    || defined(__FreeBSD_kernel__)                                            \
-    || defined(__NetBSD__)                                                    \
-    || defined(__OpenBSD__)                                                   \
-    || defined(__sun)
-  struct timeval tv[2];
-  tv[0].tv_sec  = req->atime;
-  tv[0].tv_usec = (uint64_t)(req->atime * 1000000) % 1000000;
-  tv[1].tv_sec  = req->mtime;
-  tv[1].tv_usec = (uint64_t)(req->mtime * 1000000) % 1000000;
-# if defined(__sun)
-  return futimesat(req->file, NULL, tv);
-# else
-  return futimes(req->file, tv);
-# endif
-#elif defined(__MVS__)
-  attrib_t atr;
-  memset(&atr, 0, sizeof(atr));
-  atr.att_mtimechg = 1;
-  atr.att_atimechg = 1;
-  atr.att_mtime = req->mtime;
-  atr.att_atime = req->atime;
-  return __fchattr(req->file, &atr, sizeof(atr));
-#else
-  errno = ENOSYS;
-  return -1;
-#endif
-}
-
-
-static ssize_t uv__fs_mkdtemp(uv_fs_t* req) {
-  return mkdtemp((char*) req->path) ? 0 : -1;
-}
-
-
-static ssize_t uv__fs_open(uv_fs_t* req) {
-  static int no_cloexec_support;
-  int r;
-
-  /* Try O_CLOEXEC before entering locks */
-  if (no_cloexec_support == 0) {
-#ifdef O_CLOEXEC
-    r = open(req->path, req->flags | O_CLOEXEC, req->mode);
-    if (r >= 0)
-      return r;
-    if (errno != EINVAL)
-      return r;
-    no_cloexec_support = 1;
-#endif  /* O_CLOEXEC */
-  }
-
-  if (req->cb != NULL)
-    uv_rwlock_rdlock(&req->loop->cloexec_lock);
-
-  r = open(req->path, req->flags, req->mode);
-
-  /* In case of failure `uv__cloexec` will leave error in `errno`,
-   * so it is enough to just set `r` to `-1`.
-   */
-  if (r >= 0 && uv__cloexec(r, 1) != 0) {
-    r = uv__close(r);
-    if (r != 0)
-      abort();
-    r = -1;
-  }
-
-  if (req->cb != NULL)
-    uv_rwlock_rdunlock(&req->loop->cloexec_lock);
-
-  return r;
-}
-
-
-static ssize_t uv__fs_preadv(uv_file fd,
-                             uv_buf_t* bufs,
-                             unsigned int nbufs,
-                             off_t off) {
-  uv_buf_t* buf;
-  uv_buf_t* end;
-  ssize_t result;
-  ssize_t rc;
-  size_t pos;
-
-  assert(nbufs > 0);
-
-  result = 0;
-  pos = 0;
-  buf = bufs + 0;
-  end = bufs + nbufs;
-
-  for (;;) {
-    do
-      rc = pread(fd, buf->base + pos, buf->len - pos, off + result);
-    while (rc == -1 && errno == EINTR);
-
-    if (rc == 0)
-      break;
-
-    if (rc == -1 && result == 0)
-      return UV__ERR(errno);
-
-    if (rc == -1)
-      break;  /* We read some data so return that, ignore the error. */
-
-    pos += rc;
-    result += rc;
-
-    if (pos < buf->len)
-      continue;
-
-    pos = 0;
-    buf += 1;
-
-    if (buf == end)
-      break;
-  }
-
-  return result;
-}
-
-
-static ssize_t uv__fs_read(uv_fs_t* req) {
-#if defined(__linux__)
-  static int no_preadv;
-#endif
-  unsigned int iovmax;
-  ssize_t result;
-
-  iovmax = uv__getiovmax();
-  if (req->nbufs > iovmax)
-    req->nbufs = iovmax;
-
-  if (req->off < 0) {
-    if (req->nbufs == 1)
-      result = read(req->file, req->bufs[0].base, req->bufs[0].len);
-    else
-      result = readv(req->file, (struct iovec*) req->bufs, req->nbufs);
-  } else {
-    if (req->nbufs == 1) {
-      result = pread(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
-      goto done;
-    }
-
-#if HAVE_PREADV
-    result = preadv(req->file, (struct iovec*) req->bufs, req->nbufs, req->off);
-#else
-# if defined(__linux__)
-    if (no_preadv) retry:
-# endif
-    {
-      result = uv__fs_preadv(req->file, req->bufs, req->nbufs, req->off);
-    }
-# if defined(__linux__)
-    else {
-      result = uv__preadv(req->file,
-                          (struct iovec*)req->bufs,
-                          req->nbufs,
-                          req->off);
-      if (result == -1 && errno == ENOSYS) {
-        no_preadv = 1;
-        goto retry;
-      }
-    }
-# endif
-#endif
-  }
-
-done:
-  /* Early cleanup of bufs allocation, since we're done with it. */
-  if (req->bufs != req->bufsml)
-    uv__free(req->bufs);
-
-  req->bufs = NULL;
-  req->nbufs = 0;
-
-#ifdef __PASE__
-  /* PASE returns EOPNOTSUPP when reading a directory, convert to EISDIR */
-  if (result == -1 && errno == EOPNOTSUPP) {
-    struct stat buf;
-    ssize_t rc;
-    rc = fstat(req->file, &buf);
-    if (rc == 0 && S_ISDIR(buf.st_mode)) {
-      errno = EISDIR;
-    }
-  }
-#endif
-
-  return result;
-}
-
-
-#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_8)
-#define UV_CONST_DIRENT uv__dirent_t
-#else
-#define UV_CONST_DIRENT const uv__dirent_t
-#endif
-
-
-static int uv__fs_scandir_filter(UV_CONST_DIRENT* dent) {
-  return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0;
-}
-
-
-static int uv__fs_scandir_sort(UV_CONST_DIRENT** a, UV_CONST_DIRENT** b) {
-  return strcmp((*a)->d_name, (*b)->d_name);
-}
-
-
-static ssize_t uv__fs_scandir(uv_fs_t* req) {
-  uv__dirent_t** dents;
-  int n;
-
-  dents = NULL;
-  n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort);
-
-  /* NOTE: We will use nbufs as an index field */
-  req->nbufs = 0;
-
-  if (n == 0) {
-    /* OS X still needs to deallocate some memory.
-     * Memory was allocated using the system allocator, so use free() here.
-     */
-    free(dents);
-    dents = NULL;
-  } else if (n == -1) {
-    return n;
-  }
-
-  req->ptr = dents;
-
-  return n;
-}
-
-static int uv__fs_opendir(uv_fs_t* req) {
-  uv_dir_t* dir;
-
-  dir = (uv_dir_t*)uv__malloc(sizeof(*dir));
-  if (dir == NULL)
-    goto error;
-
-  dir->dir = opendir(req->path);
-  if (dir->dir == NULL)
-    goto error;
-
-  req->ptr = dir;
-  return 0;
-
-error:
-  uv__free(dir);
-  req->ptr = NULL;
-  return -1;
-}
-
-static int uv__fs_readdir(uv_fs_t* req) {
-  uv_dir_t* dir;
-  uv_dirent_t* dirent;
-  struct dirent* res;
-  unsigned int dirent_idx;
-  unsigned int i;
-
-  dir = (uv_dir_t*)req->ptr;
-  dirent_idx = 0;
-
-  while (dirent_idx < dir->nentries) {
-    /* readdir() returns NULL on end of directory, as well as on error. errno
-       is used to differentiate between the two conditions. */
-    errno = 0;
-    res = readdir(dir->dir);
-
-    if (res == NULL) {
-      if (errno != 0)
-        goto error;
-      break;
-    }
-
-    if (strcmp(res->d_name, ".") == 0 || strcmp(res->d_name, "..") == 0)
-      continue;
-
-    dirent = &dir->dirents[dirent_idx];
-    dirent->name = uv__strdup(res->d_name);
-
-    if (dirent->name == NULL)
-      goto error;
-
-    dirent->type = uv__fs_get_dirent_type(res);
-    ++dirent_idx;
-  }
-
-  return dirent_idx;
-
-error:
-  for (i = 0; i < dirent_idx; ++i) {
-    uv__free((char*) dir->dirents[i].name);
-    dir->dirents[i].name = NULL;
-  }
-
-  return -1;
-}
-
-static int uv__fs_closedir(uv_fs_t* req) {
-  uv_dir_t* dir;
-
-  dir = (uv_dir_t*)req->ptr;
-
-  if (dir->dir != NULL) {
-    closedir(dir->dir);
-    dir->dir = NULL;
-  }
-
-  uv__free(req->ptr);
-  req->ptr = NULL;
-  return 0;
-}
-
-static ssize_t uv__fs_pathmax_size(const char* path) {
-  ssize_t pathmax;
-
-  pathmax = pathconf(path, _PC_PATH_MAX);
-
-  if (pathmax == -1)
-    pathmax = UV__PATH_MAX;
-
-  return pathmax;
-}
-
-static ssize_t uv__fs_readlink(uv_fs_t* req) {
-  ssize_t maxlen;
-  ssize_t len;
-  char* buf;
-  char* newbuf;
-
-#if defined(_POSIX_PATH_MAX) || defined(PATH_MAX)
-  maxlen = uv__fs_pathmax_size(req->path);
-#else
-  /* We may not have a real PATH_MAX.  Read size of link.  */
-  struct stat st;
-  int ret;
-  ret = lstat(req->path, &st);
-  if (ret != 0)
-    return -1;
-  if (!S_ISLNK(st.st_mode)) {
-    errno = EINVAL;
-    return -1;
-  }
-
-  maxlen = st.st_size;
-
-  /* According to readlink(2) lstat can report st_size == 0
-     for some symlinks, such as those in /proc or /sys.  */
-  if (maxlen == 0)
-    maxlen = uv__fs_pathmax_size(req->path);
-#endif
-
-  buf = (char*)uv__malloc(maxlen);
-
-  if (buf == NULL) {
-    errno = ENOMEM;
-    return -1;
-  }
-
-#if defined(__MVS__)
-  len = os390_readlink(req->path, buf, maxlen);
-#else
-  len = readlink(req->path, buf, maxlen);
-#endif
-
-  if (len == -1) {
-    uv__free(buf);
-    return -1;
-  }
-
-  /* Uncommon case: resize to make room for the trailing nul byte. */
-  if (len == maxlen) {
-    newbuf = (char*)uv__realloc(buf, len + 1);
-
-    if (newbuf == NULL) {
-      uv__free(buf);
-      return -1;
-    }
-
-    buf = newbuf;
-  }
-
-  buf[len] = '\0';
-  req->ptr = buf;
-
-  return 0;
-}
-
-static ssize_t uv__fs_realpath(uv_fs_t* req) {
-  char* buf;
-
-#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L
-  buf = realpath(req->path, NULL);
-  if (buf == NULL)
-    return -1;
-#else
-  ssize_t len;
-
-  len = uv__fs_pathmax_size(req->path);
-  buf = (char*)uv__malloc(len + 1);
-
-  if (buf == NULL) {
-    errno = ENOMEM;
-    return -1;
-  }
-
-  if (realpath(req->path, buf) == NULL) {
-    uv__free(buf);
-    return -1;
-  }
-#endif
-
-  req->ptr = buf;
-
-  return 0;
-}
-
-static ssize_t uv__fs_sendfile_emul(uv_fs_t* req) {
-  struct pollfd pfd;
-  int use_pread;
-  off_t offset;
-  ssize_t nsent;
-  ssize_t nread;
-  ssize_t nwritten;
-  size_t buflen;
-  size_t len;
-  ssize_t n;
-  int in_fd;
-  int out_fd;
-  char buf[8192];
-
-  len = req->bufsml[0].len;
-  in_fd = req->flags;
-  out_fd = req->file;
-  offset = req->off;
-  use_pread = 1;
-
-  /* Here are the rules regarding errors:
-   *
-   * 1. Read errors are reported only if nsent==0, otherwise we return nsent.
-   *    The user needs to know that some data has already been sent, to stop
-   *    them from sending it twice.
-   *
-   * 2. Write errors are always reported. Write errors are bad because they
-   *    mean data loss: we've read data but now we can't write it out.
-   *
-   * We try to use pread() and fall back to regular read() if the source fd
-   * doesn't support positional reads, for example when it's a pipe fd.
-   *
-   * If we get EAGAIN when writing to the target fd, we poll() on it until
-   * it becomes writable again.
-   *
-   * FIXME: If we get a write error when use_pread==1, it should be safe to
-   *        return the number of sent bytes instead of an error because pread()
-   *        is, in theory, idempotent. However, special files in /dev or /proc
-   *        may support pread() but not necessarily return the same data on
-   *        successive reads.
-   *
-   * FIXME: There is no way now to signal that we managed to send *some* data
-   *        before a write error.
-   */
-  for (nsent = 0; (size_t) nsent < len; ) {
-    buflen = len - nsent;
-
-    if (buflen > sizeof(buf))
-      buflen = sizeof(buf);
-
-    do
-      if (use_pread)
-        nread = pread(in_fd, buf, buflen, offset);
-      else
-        nread = read(in_fd, buf, buflen);
-    while (nread == -1 && errno == EINTR);
-
-    if (nread == 0)
-      goto out;
-
-    if (nread == -1) {
-      if (use_pread && nsent == 0 && (errno == EIO || errno == ESPIPE)) {
-        use_pread = 0;
-        continue;
-      }
-
-      if (nsent == 0)
-        nsent = -1;
-
-      goto out;
-    }
-
-    for (nwritten = 0; nwritten < nread; ) {
-      do
-        n = write(out_fd, buf + nwritten, nread - nwritten);
-      while (n == -1 && errno == EINTR);
-
-      if (n != -1) {
-        nwritten += n;
-        continue;
-      }
-
-      if (errno != EAGAIN && errno != EWOULDBLOCK) {
-        nsent = -1;
-        goto out;
-      }
-
-      pfd.fd = out_fd;
-      pfd.events = POLLOUT;
-      pfd.revents = 0;
-
-      do
-        n = poll(&pfd, 1, -1);
-      while (n == -1 && errno == EINTR);
-
-      if (n == -1 || (pfd.revents & ~POLLOUT) != 0) {
-        errno = EIO;
-        nsent = -1;
-        goto out;
-      }
-    }
-
-    offset += nread;
-    nsent += nread;
-  }
-
-out:
-  if (nsent != -1)
-    req->off = offset;
-
-  return nsent;
-}
-
-
-static ssize_t uv__fs_sendfile(uv_fs_t* req) {
-  int in_fd;
-  int out_fd;
-
-  in_fd = req->flags;
-  out_fd = req->file;
-
-#if defined(__linux__) || defined(__sun)
-  {
-    off_t off;
-    ssize_t r;
-
-    off = req->off;
-    r = sendfile(out_fd, in_fd, &off, req->bufsml[0].len);
-
-    /* sendfile() on SunOS returns EINVAL if the target fd is not a socket but
-     * it still writes out data. Fortunately, we can detect it by checking if
-     * the offset has been updated.
-     */
-    if (r != -1 || off > req->off) {
-      r = off - req->off;
-      req->off = off;
-      return r;
-    }
-
-    if (errno == EINVAL ||
-        errno == EIO ||
-        errno == ENOTSOCK ||
-        errno == EXDEV) {
-      errno = 0;
-      return uv__fs_sendfile_emul(req);
-    }
-
-    return -1;
-  }
-#elif defined(__APPLE__)           || \
-      defined(__DragonFly__)       || \
-      defined(__FreeBSD__)         || \
-      defined(__FreeBSD_kernel__)
-  {
-    off_t len;
-    ssize_t r;
-
-    /* sendfile() on FreeBSD and Darwin returns EAGAIN if the target fd is in
-     * non-blocking mode and not all data could be written. If a non-zero
-     * number of bytes have been sent, we don't consider it an error.
-     */
-
-#if defined(__FreeBSD__) || defined(__DragonFly__)
-    len = 0;
-    r = sendfile(in_fd, out_fd, req->off, req->bufsml[0].len, NULL, &len, 0);
-#elif defined(__FreeBSD_kernel__)
-    len = 0;
-    r = bsd_sendfile(in_fd,
-                     out_fd,
-                     req->off,
-                     req->bufsml[0].len,
-                     NULL,
-                     &len,
-                     0);
-#else
-    /* The darwin sendfile takes len as an input for the length to send,
-     * so make sure to initialize it with the caller's value. */
-    len = req->bufsml[0].len;
-    r = sendfile(in_fd, out_fd, req->off, &len, NULL, 0);
-#endif
-
-     /*
-     * The man page for sendfile(2) on DragonFly states that `len` contains
-     * a meaningful value ONLY in case of EAGAIN and EINTR.
-     * Nothing is said about it's value in case of other errors, so better
-     * not depend on the potential wrong assumption that is was not modified
-     * by the syscall.
-     */
-    if (r == 0 || ((errno == EAGAIN || errno == EINTR) && len != 0)) {
-      req->off += len;
-      return (ssize_t) len;
-    }
-
-    if (errno == EINVAL ||
-        errno == EIO ||
-        errno == ENOTSOCK ||
-        errno == EXDEV) {
-      errno = 0;
-      return uv__fs_sendfile_emul(req);
-    }
-
-    return -1;
-  }
-#else
-  /* Squelch compiler warnings. */
-  (void) &in_fd;
-  (void) &out_fd;
-
-  return uv__fs_sendfile_emul(req);
-#endif
-}
-
-
-static ssize_t uv__fs_utime(uv_fs_t* req) {
-#if defined(__linux__)                                                         \
-    || defined(_AIX71)                                                         \
-    || defined(__sun)                                                          \
-    || defined(__HAIKU__)
-  /* utimesat() has nanosecond resolution but we stick to microseconds
-   * for the sake of consistency with other platforms.
-   */
-  struct timespec ts[2];
-  ts[0].tv_sec  = req->atime;
-  ts[0].tv_nsec = (uint64_t)(req->atime * 1000000) % 1000000 * 1000;
-  ts[1].tv_sec  = req->mtime;
-  ts[1].tv_nsec = (uint64_t)(req->mtime * 1000000) % 1000000 * 1000;
-  return utimensat(AT_FDCWD, req->path, ts, 0);
-#elif defined(__APPLE__)                                                      \
-    || defined(__DragonFly__)                                                 \
-    || defined(__FreeBSD__)                                                   \
-    || defined(__FreeBSD_kernel__)                                            \
-    || defined(__NetBSD__)                                                    \
-    || defined(__OpenBSD__)
-  struct timeval tv[2];
-  tv[0].tv_sec  = req->atime;
-  tv[0].tv_usec = (uint64_t)(req->atime * 1000000) % 1000000;
-  tv[1].tv_sec  = req->mtime;
-  tv[1].tv_usec = (uint64_t)(req->mtime * 1000000) % 1000000;
-  return utimes(req->path, tv);
-#elif defined(_AIX)                                                           \
-    && !defined(_AIX71)
-  struct utimbuf buf;
-  buf.actime = req->atime;
-  buf.modtime = req->mtime;
-  return utime(req->path, &buf);
-#elif defined(__MVS__)
-  attrib_t atr;
-  memset(&atr, 0, sizeof(atr));
-  atr.att_mtimechg = 1;
-  atr.att_atimechg = 1;
-  atr.att_mtime = req->mtime;
-  atr.att_atime = req->atime;
-  return __lchattr((char*) req->path, &atr, sizeof(atr));
-#else
-  errno = ENOSYS;
-  return -1;
-#endif
-}
-
-
-static ssize_t uv__fs_write(uv_fs_t* req) {
-#if defined(__linux__)
-  static int no_pwritev;
-#endif
-  ssize_t r;
-
-  /* Serialize writes on OS X, concurrent write() and pwrite() calls result in
-   * data loss. We can't use a per-file descriptor lock, the descriptor may be
-   * a dup().
-   */
-#if defined(__APPLE__)
-  static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
-
-  if (pthread_mutex_lock(&lock))
-    abort();
-#endif
-
-  if (req->off < 0) {
-    if (req->nbufs == 1)
-      r = write(req->file, req->bufs[0].base, req->bufs[0].len);
-    else
-      r = writev(req->file, (struct iovec*) req->bufs, req->nbufs);
-  } else {
-    if (req->nbufs == 1) {
-      r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
-      goto done;
-    }
-#if HAVE_PREADV
-    r = pwritev(req->file, (struct iovec*) req->bufs, req->nbufs, req->off);
-#else
-# if defined(__linux__)
-    if (no_pwritev) retry:
-# endif
-    {
-      r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
-    }
-# if defined(__linux__)
-    else {
-      r = uv__pwritev(req->file,
-                      (struct iovec*) req->bufs,
-                      req->nbufs,
-                      req->off);
-      if (r == -1 && errno == ENOSYS) {
-        no_pwritev = 1;
-        goto retry;
-      }
-    }
-# endif
-#endif
-  }
-
-done:
-#if defined(__APPLE__)
-  if (pthread_mutex_unlock(&lock))
-    abort();
-#endif
-
-  return r;
-}
-
-static ssize_t uv__fs_copyfile(uv_fs_t* req) {
-  uv_fs_t fs_req;
-  uv_file srcfd;
-  uv_file dstfd;
-  struct stat src_statsbuf;
-  struct stat dst_statsbuf;
-  int dst_flags;
-  int result;
-  int err;
-  size_t bytes_to_send;
-  int64_t in_offset;
-
-  dstfd = -1;
-  err = 0;
-
-  /* Open the source file. */
-  srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
-  uv_fs_req_cleanup(&fs_req);
-
-  if (srcfd < 0)
-    return srcfd;
-
-  /* Get the source file's mode. */
-  if (fstat(srcfd, &src_statsbuf)) {
-    err = UV__ERR(errno);
-    goto out;
-  }
-
-  dst_flags = O_WRONLY | O_CREAT | O_TRUNC;
-
-  if (req->flags & UV_FS_COPYFILE_EXCL)
-    dst_flags |= O_EXCL;
-
-  /* Open the destination file. */
-  dstfd = uv_fs_open(NULL,
-                     &fs_req,
-                     req->new_path,
-                     dst_flags,
-                     src_statsbuf.st_mode,
-                     NULL);
-  uv_fs_req_cleanup(&fs_req);
-
-  if (dstfd < 0) {
-    err = dstfd;
-    goto out;
-  }
-
-  /* Get the destination file's mode. */
-  if (fstat(dstfd, &dst_statsbuf)) {
-    err = UV__ERR(errno);
-    goto out;
-  }
-
-  /* Check if srcfd and dstfd refer to the same file */
-  if (src_statsbuf.st_dev == dst_statsbuf.st_dev &&
-      src_statsbuf.st_ino == dst_statsbuf.st_ino) {
-    goto out;
-  }
-
-  if (fchmod(dstfd, src_statsbuf.st_mode) == -1) {
-    err = UV__ERR(errno);
-    goto out;
-  }
-
-#ifdef FICLONE
-  if (req->flags & UV_FS_COPYFILE_FICLONE ||
-      req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
-    if (ioctl(dstfd, FICLONE, srcfd) == -1) {
-      /* If an error occurred that the sendfile fallback also won't handle, or
-         this is a force clone then exit. Otherwise, fall through to try using
-         sendfile(). */
-      if (errno != ENOTTY && errno != EOPNOTSUPP && errno != EXDEV) {
-        err = UV__ERR(errno);
-        goto out;
-      } else if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
-        err = UV_ENOTSUP;
-        goto out;
-      }
-    } else {
-      goto out;
-    }
-  }
-#else
-  if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
-    err = UV_ENOSYS;
-    goto out;
-  }
-#endif
-
-  bytes_to_send = src_statsbuf.st_size;
-  in_offset = 0;
-  while (bytes_to_send != 0) {
-    err = uv_fs_sendfile(NULL,
-                         &fs_req,
-                         dstfd,
-                         srcfd,
-                         in_offset,
-                         bytes_to_send,
-                         NULL);
-    uv_fs_req_cleanup(&fs_req);
-    if (err < 0)
-      break;
-    bytes_to_send -= fs_req.result;
-    in_offset += fs_req.result;
-  }
-
-out:
-  if (err < 0)
-    result = err;
-  else
-    result = 0;
-
-  /* Close the source file. */
-  err = uv__close_nocheckstdio(srcfd);
-
-  /* Don't overwrite any existing errors. */
-  if (err != 0 && result == 0)
-    result = err;
-
-  /* Close the destination file if it is open. */
-  if (dstfd >= 0) {
-    err = uv__close_nocheckstdio(dstfd);
-
-    /* Don't overwrite any existing errors. */
-    if (err != 0 && result == 0)
-      result = err;
-
-    /* Remove the destination file if something went wrong. */
-    if (result != 0) {
-      uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
-      /* Ignore the unlink return value, as an error already happened. */
-      uv_fs_req_cleanup(&fs_req);
-    }
-  }
-
-  if (result == 0)
-    return 0;
-
-  errno = UV__ERR(result);
-  return -1;
-}
-
-static void uv__to_stat(struct stat* src, uv_stat_t* dst) {
-  dst->st_dev = src->st_dev;
-  dst->st_mode = src->st_mode;
-  dst->st_nlink = src->st_nlink;
-  dst->st_uid = src->st_uid;
-  dst->st_gid = src->st_gid;
-  dst->st_rdev = src->st_rdev;
-  dst->st_ino = src->st_ino;
-  dst->st_size = src->st_size;
-  dst->st_blksize = src->st_blksize;
-  dst->st_blocks = src->st_blocks;
-
-#if defined(__APPLE__)
-  dst->st_atim.tv_sec = src->st_atimespec.tv_sec;
-  dst->st_atim.tv_nsec = src->st_atimespec.tv_nsec;
-  dst->st_mtim.tv_sec = src->st_mtimespec.tv_sec;
-  dst->st_mtim.tv_nsec = src->st_mtimespec.tv_nsec;
-  dst->st_ctim.tv_sec = src->st_ctimespec.tv_sec;
-  dst->st_ctim.tv_nsec = src->st_ctimespec.tv_nsec;
-  dst->st_birthtim.tv_sec = src->st_birthtimespec.tv_sec;
-  dst->st_birthtim.tv_nsec = src->st_birthtimespec.tv_nsec;
-  dst->st_flags = src->st_flags;
-  dst->st_gen = src->st_gen;
-#elif defined(__ANDROID__)
-  dst->st_atim.tv_sec = src->st_atime;
-  dst->st_atim.tv_nsec = src->st_atimensec;
-  dst->st_mtim.tv_sec = src->st_mtime;
-  dst->st_mtim.tv_nsec = src->st_mtimensec;
-  dst->st_ctim.tv_sec = src->st_ctime;
-  dst->st_ctim.tv_nsec = src->st_ctimensec;
-  dst->st_birthtim.tv_sec = src->st_ctime;
-  dst->st_birthtim.tv_nsec = src->st_ctimensec;
-  dst->st_flags = 0;
-  dst->st_gen = 0;
-#elif !defined(_AIX) && (       \
-    defined(__DragonFly__)   || \
-    defined(__FreeBSD__)     || \
-    defined(__OpenBSD__)     || \
-    defined(__NetBSD__)      || \
-    defined(_GNU_SOURCE)     || \
-    defined(_BSD_SOURCE)     || \
-    defined(_SVID_SOURCE)    || \
-    defined(_XOPEN_SOURCE)   || \
-    defined(_DEFAULT_SOURCE))
-  dst->st_atim.tv_sec = src->st_atim.tv_sec;
-  dst->st_atim.tv_nsec = src->st_atim.tv_nsec;
-  dst->st_mtim.tv_sec = src->st_mtim.tv_sec;
-  dst->st_mtim.tv_nsec = src->st_mtim.tv_nsec;
-  dst->st_ctim.tv_sec = src->st_ctim.tv_sec;
-  dst->st_ctim.tv_nsec = src->st_ctim.tv_nsec;
-# if defined(__FreeBSD__)    || \
-     defined(__NetBSD__)
-  dst->st_birthtim.tv_sec = src->st_birthtim.tv_sec;
-  dst->st_birthtim.tv_nsec = src->st_birthtim.tv_nsec;
-  dst->st_flags = src->st_flags;
-  dst->st_gen = src->st_gen;
-# else
-  dst->st_birthtim.tv_sec = src->st_ctim.tv_sec;
-  dst->st_birthtim.tv_nsec = src->st_ctim.tv_nsec;
-  dst->st_flags = 0;
-  dst->st_gen = 0;
-# endif
-#else
-  dst->st_atim.tv_sec = src->st_atime;
-  dst->st_atim.tv_nsec = 0;
-  dst->st_mtim.tv_sec = src->st_mtime;
-  dst->st_mtim.tv_nsec = 0;
-  dst->st_ctim.tv_sec = src->st_ctime;
-  dst->st_ctim.tv_nsec = 0;
-  dst->st_birthtim.tv_sec = src->st_ctime;
-  dst->st_birthtim.tv_nsec = 0;
-  dst->st_flags = 0;
-  dst->st_gen = 0;
-#endif
-}
-
-
-static int uv__fs_statx(int fd,
-                        const char* path,
-                        int is_fstat,
-                        int is_lstat,
-                        uv_stat_t* buf) {
-  STATIC_ASSERT(UV_ENOSYS != -1);
-#ifdef __linux__
-  static int no_statx;
-  struct uv__statx statxbuf;
-  int dirfd;
-  int flags;
-  int mode;
-  int rc;
-
-  if (no_statx)
-    return UV_ENOSYS;
-
-  dirfd = AT_FDCWD;
-  flags = 0; /* AT_STATX_SYNC_AS_STAT */
-  mode = 0xFFF; /* STATX_BASIC_STATS + STATX_BTIME */
-
-  if (is_fstat) {
-    dirfd = fd;
-    flags |= 0x1000; /* AT_EMPTY_PATH */
-  }
-
-  if (is_lstat)
-    flags |= AT_SYMLINK_NOFOLLOW;
-
-  rc = uv__statx(dirfd, path, flags, mode, &statxbuf);
-
-  if (rc == -1) {
-    /* EPERM happens when a seccomp filter rejects the system call.
-     * Has been observed with libseccomp < 2.3.3 and docker < 18.04.
-     */
-    if (errno != EINVAL && errno != EPERM && errno != ENOSYS)
-      return -1;
-
-    no_statx = 1;
-    return UV_ENOSYS;
-  }
-
-  buf->st_dev = 256 * statxbuf.stx_dev_major + statxbuf.stx_dev_minor;
-  buf->st_mode = statxbuf.stx_mode;
-  buf->st_nlink = statxbuf.stx_nlink;
-  buf->st_uid = statxbuf.stx_uid;
-  buf->st_gid = statxbuf.stx_gid;
-  buf->st_rdev = statxbuf.stx_rdev_major;
-  buf->st_ino = statxbuf.stx_ino;
-  buf->st_size = statxbuf.stx_size;
-  buf->st_blksize = statxbuf.stx_blksize;
-  buf->st_blocks = statxbuf.stx_blocks;
-  buf->st_atim.tv_sec = statxbuf.stx_atime.tv_sec;
-  buf->st_atim.tv_nsec = statxbuf.stx_atime.tv_nsec;
-  buf->st_mtim.tv_sec = statxbuf.stx_mtime.tv_sec;
-  buf->st_mtim.tv_nsec = statxbuf.stx_mtime.tv_nsec;
-  buf->st_ctim.tv_sec = statxbuf.stx_ctime.tv_sec;
-  buf->st_ctim.tv_nsec = statxbuf.stx_ctime.tv_nsec;
-  buf->st_birthtim.tv_sec = statxbuf.stx_btime.tv_sec;
-  buf->st_birthtim.tv_nsec = statxbuf.stx_btime.tv_nsec;
-  buf->st_flags = 0;
-  buf->st_gen = 0;
-
-  return 0;
-#else
-  return UV_ENOSYS;
-#endif /* __linux__ */
-}
-
-
-static int uv__fs_stat(const char *path, uv_stat_t *buf) {
-  struct stat pbuf;
-  int ret;
-
-  ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 0, buf);
-  if (ret != UV_ENOSYS)
-    return ret;
-
-  ret = stat(path, &pbuf);
-  if (ret == 0)
-    uv__to_stat(&pbuf, buf);
-
-  return ret;
-}
-
-
-static int uv__fs_lstat(const char *path, uv_stat_t *buf) {
-  struct stat pbuf;
-  int ret;
-
-  ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 1, buf);
-  if (ret != UV_ENOSYS)
-    return ret;
-
-  ret = lstat(path, &pbuf);
-  if (ret == 0)
-    uv__to_stat(&pbuf, buf);
-
-  return ret;
-}
-
-
-static int uv__fs_fstat(int fd, uv_stat_t *buf) {
-  struct stat pbuf;
-  int ret;
-
-  ret = uv__fs_statx(fd, "", /* is_fstat */ 1, /* is_lstat */ 0, buf);
-  if (ret != UV_ENOSYS)
-    return ret;
-
-  ret = fstat(fd, &pbuf);
-  if (ret == 0)
-    uv__to_stat(&pbuf, buf);
-
-  return ret;
-}
-
-static size_t uv__fs_buf_offset(uv_buf_t* bufs, size_t size) {
-  size_t offset;
-  /* Figure out which bufs are done */
-  for (offset = 0; size > 0 && bufs[offset].len <= size; ++offset)
-    size -= bufs[offset].len;
-
-  /* Fix a partial read/write */
-  if (size > 0) {
-    bufs[offset].base += size;
-    bufs[offset].len -= size;
-  }
-  return offset;
-}
-
-static ssize_t uv__fs_write_all(uv_fs_t* req) {
-  unsigned int iovmax;
-  unsigned int nbufs;
-  uv_buf_t* bufs;
-  ssize_t total;
-  ssize_t result;
-
-  iovmax = uv__getiovmax();
-  nbufs = req->nbufs;
-  bufs = req->bufs;
-  total = 0;
-
-  while (nbufs > 0) {
-    req->nbufs = nbufs;
-    if (req->nbufs > iovmax)
-      req->nbufs = iovmax;
-
-    do
-      result = uv__fs_write(req);
-    while (result < 0 && errno == EINTR);
-
-    if (result <= 0) {
-      if (total == 0)
-        total = result;
-      break;
-    }
-
-    if (req->off >= 0)
-      req->off += result;
-
-    req->nbufs = uv__fs_buf_offset(req->bufs, result);
-    req->bufs += req->nbufs;
-    nbufs -= req->nbufs;
-    total += result;
-  }
-
-  if (bufs != req->bufsml)
-    uv__free(bufs);
-
-  req->bufs = NULL;
-  req->nbufs = 0;
-
-  return total;
-}
-
-
-static void uv__fs_work(struct uv__work* w) {
-  int retry_on_eintr;
-  uv_fs_t* req;
-  ssize_t r;
-
-  req = container_of(w, uv_fs_t, work_req);
-  retry_on_eintr = !(req->fs_type == UV_FS_CLOSE ||
-                     req->fs_type == UV_FS_READ);
-
-  do {
-    errno = 0;
-
-#define X(type, action)                                                       \
-  case UV_FS_ ## type:                                                        \
-    r = action;                                                               \
-    break;
-
-    switch (req->fs_type) {
-    X(ACCESS, access(req->path, req->flags));
-    X(CHMOD, chmod(req->path, req->mode));
-    X(CHOWN, chown(req->path, req->uid, req->gid));
-    X(CLOSE, uv__fs_close(req->file));
-    X(COPYFILE, uv__fs_copyfile(req));
-    X(FCHMOD, fchmod(req->file, req->mode));
-    X(FCHOWN, fchown(req->file, req->uid, req->gid));
-    X(LCHOWN, lchown(req->path, req->uid, req->gid));
-    X(FDATASYNC, uv__fs_fdatasync(req));
-    X(FSTAT, uv__fs_fstat(req->file, &req->statbuf));
-    X(FSYNC, uv__fs_fsync(req));
-    X(FTRUNCATE, ftruncate(req->file, req->off));
-    X(FUTIME, uv__fs_futime(req));
-    X(LSTAT, uv__fs_lstat(req->path, &req->statbuf));
-    X(LINK, link(req->path, req->new_path));
-    X(MKDIR, mkdir(req->path, req->mode));
-    X(MKDTEMP, uv__fs_mkdtemp(req));
-    X(OPEN, uv__fs_open(req));
-    X(READ, uv__fs_read(req));
-    X(SCANDIR, uv__fs_scandir(req));
-    X(OPENDIR, uv__fs_opendir(req));
-    X(READDIR, uv__fs_readdir(req));
-    X(CLOSEDIR, uv__fs_closedir(req));
-    X(READLINK, uv__fs_readlink(req));
-    X(REALPATH, uv__fs_realpath(req));
-    X(RENAME, rename(req->path, req->new_path));
-    X(RMDIR, rmdir(req->path));
-    X(SENDFILE, uv__fs_sendfile(req));
-    X(STAT, uv__fs_stat(req->path, &req->statbuf));
-    X(SYMLINK, symlink(req->path, req->new_path));
-    X(UNLINK, unlink(req->path));
-    X(UTIME, uv__fs_utime(req));
-    X(WRITE, uv__fs_write_all(req));
-    default: abort();
-    }
-#undef X
-  } while (r == -1 && errno == EINTR && retry_on_eintr);
-
-  if (r == -1)
-    req->result = UV__ERR(errno);
-  else
-    req->result = r;
-
-  if (r == 0 && (req->fs_type == UV_FS_STAT ||
-                 req->fs_type == UV_FS_FSTAT ||
-                 req->fs_type == UV_FS_LSTAT)) {
-    req->ptr = &req->statbuf;
-  }
-}
-
-
-static void uv__fs_done(struct uv__work* w, int status) {
-  uv_fs_t* req;
-
-  req = container_of(w, uv_fs_t, work_req);
-  uv__req_unregister(req->loop, req);
-
-  if (status == UV_ECANCELED) {
-    assert(req->result == 0);
-    req->result = UV_ECANCELED;
-  }
-
-  req->cb(req);
-}
-
-
-int uv_fs_access(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 const char* path,
-                 int flags,
-                 uv_fs_cb cb) {
-  INIT(ACCESS);
-  PATH;
-  req->flags = flags;
-  POST;
-}
-
-
-int uv_fs_chmod(uv_loop_t* loop,
-                uv_fs_t* req,
-                const char* path,
-                int mode,
-                uv_fs_cb cb) {
-  INIT(CHMOD);
-  PATH;
-  req->mode = mode;
-  POST;
-}
-
-
-int uv_fs_chown(uv_loop_t* loop,
-                uv_fs_t* req,
-                const char* path,
-                uv_uid_t uid,
-                uv_gid_t gid,
-                uv_fs_cb cb) {
-  INIT(CHOWN);
-  PATH;
-  req->uid = uid;
-  req->gid = gid;
-  POST;
-}
-
-
-int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
-  INIT(CLOSE);
-  req->file = file;
-  POST;
-}
-
-
-int uv_fs_fchmod(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 uv_file file,
-                 int mode,
-                 uv_fs_cb cb) {
-  INIT(FCHMOD);
-  req->file = file;
-  req->mode = mode;
-  POST;
-}
-
-
-int uv_fs_fchown(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 uv_file file,
-                 uv_uid_t uid,
-                 uv_gid_t gid,
-                 uv_fs_cb cb) {
-  INIT(FCHOWN);
-  req->file = file;
-  req->uid = uid;
-  req->gid = gid;
-  POST;
-}
-
-
-int uv_fs_lchown(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 const char* path,
-                 uv_uid_t uid,
-                 uv_gid_t gid,
-                 uv_fs_cb cb) {
-  INIT(LCHOWN);
-  PATH;
-  req->uid = uid;
-  req->gid = gid;
-  POST;
-}
-
-
-int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
-  INIT(FDATASYNC);
-  req->file = file;
-  POST;
-}
-
-
-int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
-  INIT(FSTAT);
-  req->file = file;
-  POST;
-}
-
-
-int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
-  INIT(FSYNC);
-  req->file = file;
-  POST;
-}
-
-
-int uv_fs_ftruncate(uv_loop_t* loop,
-                    uv_fs_t* req,
-                    uv_file file,
-                    int64_t off,
-                    uv_fs_cb cb) {
-  INIT(FTRUNCATE);
-  req->file = file;
-  req->off = off;
-  POST;
-}
-
-
-int uv_fs_futime(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 uv_file file,
-                 double atime,
-                 double mtime,
-                 uv_fs_cb cb) {
-  INIT(FUTIME);
-  req->file = file;
-  req->atime = atime;
-  req->mtime = mtime;
-  POST;
-}
-
-
-int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  INIT(LSTAT);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_link(uv_loop_t* loop,
-               uv_fs_t* req,
-               const char* path,
-               const char* new_path,
-               uv_fs_cb cb) {
-  INIT(LINK);
-  PATH2;
-  POST;
-}
-
-
-int uv_fs_mkdir(uv_loop_t* loop,
-                uv_fs_t* req,
-                const char* path,
-                int mode,
-                uv_fs_cb cb) {
-  INIT(MKDIR);
-  PATH;
-  req->mode = mode;
-  POST;
-}
-
-
-int uv_fs_mkdtemp(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char* tpl,
-                  uv_fs_cb cb) {
-  INIT(MKDTEMP);
-  req->path = uv__strdup(tpl);
-  if (req->path == NULL)
-    return UV_ENOMEM;
-  POST;
-}
-
-
-int uv_fs_open(uv_loop_t* loop,
-               uv_fs_t* req,
-               const char* path,
-               int flags,
-               int mode,
-               uv_fs_cb cb) {
-  INIT(OPEN);
-  PATH;
-  req->flags = flags;
-  req->mode = mode;
-  POST;
-}
-
-
-int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
-               uv_file file,
-               const uv_buf_t bufs[],
-               unsigned int nbufs,
-               int64_t off,
-               uv_fs_cb cb) {
-  INIT(READ);
-
-  if (bufs == NULL || nbufs == 0)
-    return UV_EINVAL;
-
-  req->file = file;
-
-  req->nbufs = nbufs;
-  req->bufs = req->bufsml;
-  if (nbufs > ARRAY_SIZE(req->bufsml))
-    req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs));
-
-  if (req->bufs == NULL)
-    return UV_ENOMEM;
-
-  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
-
-  req->off = off;
-  POST;
-}
-
-
-int uv_fs_scandir(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char* path,
-                  int flags,
-                  uv_fs_cb cb) {
-  INIT(SCANDIR);
-  PATH;
-  req->flags = flags;
-  POST;
-}
-
-int uv_fs_opendir(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char* path,
-                  uv_fs_cb cb) {
-  INIT(OPENDIR);
-  PATH;
-  POST;
-}
-
-int uv_fs_readdir(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  uv_dir_t* dir,
-                  uv_fs_cb cb) {
-  INIT(READDIR);
-
-  if (dir == NULL || dir->dir == NULL || dir->dirents == NULL)
-    return UV_EINVAL;
-
-  req->ptr = dir;
-  POST;
-}
-
-int uv_fs_closedir(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   uv_dir_t* dir,
-                   uv_fs_cb cb) {
-  INIT(CLOSEDIR);
-
-  if (dir == NULL)
-    return UV_EINVAL;
-
-  req->ptr = dir;
-  POST;
-}
-
-int uv_fs_readlink(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   const char* path,
-                   uv_fs_cb cb) {
-  INIT(READLINK);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_realpath(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char * path,
-                  uv_fs_cb cb) {
-  INIT(REALPATH);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_rename(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 const char* path,
-                 const char* new_path,
-                 uv_fs_cb cb) {
-  INIT(RENAME);
-  PATH2;
-  POST;
-}
-
-
-int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  INIT(RMDIR);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_sendfile(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   uv_file out_fd,
-                   uv_file in_fd,
-                   int64_t off,
-                   size_t len,
-                   uv_fs_cb cb) {
-  INIT(SENDFILE);
-  req->flags = in_fd; /* hack */
-  req->file = out_fd;
-  req->off = off;
-  req->bufsml[0].len = len;
-  POST;
-}
-
-
-int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  INIT(STAT);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_symlink(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char* path,
-                  const char* new_path,
-                  int flags,
-                  uv_fs_cb cb) {
-  INIT(SYMLINK);
-  PATH2;
-  req->flags = flags;
-  POST;
-}
-
-
-int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  INIT(UNLINK);
-  PATH;
-  POST;
-}
-
-
-int uv_fs_utime(uv_loop_t* loop,
-                uv_fs_t* req,
-                const char* path,
-                double atime,
-                double mtime,
-                uv_fs_cb cb) {
-  INIT(UTIME);
-  PATH;
-  req->atime = atime;
-  req->mtime = mtime;
-  POST;
-}
-
-
-int uv_fs_write(uv_loop_t* loop,
-                uv_fs_t* req,
-                uv_file file,
-                const uv_buf_t bufs[],
-                unsigned int nbufs,
-                int64_t off,
-                uv_fs_cb cb) {
-  INIT(WRITE);
-
-  if (bufs == NULL || nbufs == 0)
-    return UV_EINVAL;
-
-  req->file = file;
-
-  req->nbufs = nbufs;
-  req->bufs = req->bufsml;
-  if (nbufs > ARRAY_SIZE(req->bufsml))
-    req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs));
-
-  if (req->bufs == NULL)
-    return UV_ENOMEM;
-
-  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
-
-  req->off = off;
-  POST;
-}
-
-
-void uv_fs_req_cleanup(uv_fs_t* req) {
-  if (req == NULL)
-    return;
-
-  /* Only necessary for asychronous requests, i.e., requests with a callback.
-   * Synchronous ones don't copy their arguments and have req->path and
-   * req->new_path pointing to user-owned memory.  UV_FS_MKDTEMP is the
-   * exception to the rule, it always allocates memory.
-   */
-  if (req->path != NULL && (req->cb != NULL || req->fs_type == UV_FS_MKDTEMP))
-    uv__free((void*) req->path);  /* Memory is shared with req->new_path. */
-
-  req->path = NULL;
-  req->new_path = NULL;
-
-  if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
-    uv__fs_readdir_cleanup(req);
-
-  if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
-    uv__fs_scandir_cleanup(req);
-
-  if (req->bufs != req->bufsml)
-    uv__free(req->bufs);
-  req->bufs = NULL;
-
-  if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
-    uv__free(req->ptr);
-  req->ptr = NULL;
-}
-
-
-int uv_fs_copyfile(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   const char* path,
-                   const char* new_path,
-                   int flags,
-                   uv_fs_cb cb) {
-  INIT(COPYFILE);
-
-  if (flags & ~(UV_FS_COPYFILE_EXCL |
-                UV_FS_COPYFILE_FICLONE |
-                UV_FS_COPYFILE_FICLONE_FORCE)) {
-    return UV_EINVAL;
-  }
-
-  PATH2;
-  req->flags = flags;
-  POST;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/fsevents.cpp b/wpiutil/src/main/native/libuv/src/unix/fsevents.cpp
deleted file mode 100644
index 32d280f..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/fsevents.cpp
+++ /dev/null
@@ -1,922 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#if TARGET_OS_IPHONE || MAC_OS_X_VERSION_MAX_ALLOWED < 1070
-
-/* iOS (currently) doesn't provide the FSEvents-API (nor CoreServices) */
-/* macOS prior to 10.7 doesn't provide the full FSEvents API so use kqueue */
-
-int uv__fsevents_init(uv_fs_event_t* handle) {
-  return 0;
-}
-
-
-int uv__fsevents_close(uv_fs_event_t* handle) {
-  return 0;
-}
-
-
-void uv__fsevents_loop_delete(uv_loop_t* loop) {
-}
-
-#else /* TARGET_OS_IPHONE */
-
-#include <dlfcn.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <pthread.h>
-
-#include <CoreFoundation/CFRunLoop.h>
-#include <CoreServices/CoreServices.h>
-
-/* These are macros to avoid "initializer element is not constant" errors
- * with old versions of gcc.
- */
-#define kFSEventsModified (kFSEventStreamEventFlagItemFinderInfoMod |         \
-                           kFSEventStreamEventFlagItemModified |              \
-                           kFSEventStreamEventFlagItemInodeMetaMod |          \
-                           kFSEventStreamEventFlagItemChangeOwner |           \
-                           kFSEventStreamEventFlagItemXattrMod)
-
-#define kFSEventsRenamed  (kFSEventStreamEventFlagItemCreated |               \
-                           kFSEventStreamEventFlagItemRemoved |               \
-                           kFSEventStreamEventFlagItemRenamed)
-
-#define kFSEventsSystem   (kFSEventStreamEventFlagUserDropped |               \
-                           kFSEventStreamEventFlagKernelDropped |             \
-                           kFSEventStreamEventFlagEventIdsWrapped |           \
-                           kFSEventStreamEventFlagHistoryDone |               \
-                           kFSEventStreamEventFlagMount |                     \
-                           kFSEventStreamEventFlagUnmount |                   \
-                           kFSEventStreamEventFlagRootChanged)
-
-typedef struct uv__fsevents_event_s uv__fsevents_event_t;
-typedef struct uv__cf_loop_signal_s uv__cf_loop_signal_t;
-typedef struct uv__cf_loop_state_s uv__cf_loop_state_t;
-
-enum uv__cf_loop_signal_type_e {
-  kUVCFLoopSignalRegular,
-  kUVCFLoopSignalClosing
-};
-typedef enum uv__cf_loop_signal_type_e uv__cf_loop_signal_type_t;
-
-struct uv__cf_loop_signal_s {
-  QUEUE member;
-  uv_fs_event_t* handle;
-  uv__cf_loop_signal_type_t type;
-};
-
-struct uv__fsevents_event_s {
-  QUEUE member;
-  int events;
-  char path[1];
-};
-
-struct uv__cf_loop_state_s {
-  CFRunLoopRef loop;
-  CFRunLoopSourceRef signal_source;
-  int fsevent_need_reschedule;
-  FSEventStreamRef fsevent_stream;
-  uv_sem_t fsevent_sem;
-  uv_mutex_t fsevent_mutex;
-  void* fsevent_handles[2];
-  unsigned int fsevent_handle_count;
-};
-
-/* Forward declarations */
-static void uv__cf_loop_cb(void* arg);
-static void* uv__cf_loop_runner(void* arg);
-static int uv__cf_loop_signal(uv_loop_t* loop,
-                              uv_fs_event_t* handle,
-                              uv__cf_loop_signal_type_t type);
-
-/* Lazy-loaded by uv__fsevents_global_init(). */
-static CFArrayRef (*pCFArrayCreate)(CFAllocatorRef,
-                                    const void**,
-                                    CFIndex,
-                                    const CFArrayCallBacks*);
-static void (*pCFRelease)(CFTypeRef);
-static void (*pCFRunLoopAddSource)(CFRunLoopRef,
-                                   CFRunLoopSourceRef,
-                                   CFStringRef);
-static CFRunLoopRef (*pCFRunLoopGetCurrent)(void);
-static void (*pCFRunLoopRemoveSource)(CFRunLoopRef,
-                                      CFRunLoopSourceRef,
-                                      CFStringRef);
-static void (*pCFRunLoopRun)(void);
-static CFRunLoopSourceRef (*pCFRunLoopSourceCreate)(CFAllocatorRef,
-                                                    CFIndex,
-                                                    CFRunLoopSourceContext*);
-static void (*pCFRunLoopSourceSignal)(CFRunLoopSourceRef);
-static void (*pCFRunLoopStop)(CFRunLoopRef);
-static void (*pCFRunLoopWakeUp)(CFRunLoopRef);
-static CFStringRef (*pCFStringCreateWithFileSystemRepresentation)(
-    CFAllocatorRef,
-    const char*);
-static CFStringEncoding (*pCFStringGetSystemEncoding)(void);
-static CFStringRef (*pkCFRunLoopDefaultMode);
-static FSEventStreamRef (*pFSEventStreamCreate)(CFAllocatorRef,
-                                                FSEventStreamCallback,
-                                                FSEventStreamContext*,
-                                                CFArrayRef,
-                                                FSEventStreamEventId,
-                                                CFTimeInterval,
-                                                FSEventStreamCreateFlags);
-static void (*pFSEventStreamFlushSync)(FSEventStreamRef);
-static void (*pFSEventStreamInvalidate)(FSEventStreamRef);
-static void (*pFSEventStreamRelease)(FSEventStreamRef);
-static void (*pFSEventStreamScheduleWithRunLoop)(FSEventStreamRef,
-                                                 CFRunLoopRef,
-                                                 CFStringRef);
-static Boolean (*pFSEventStreamStart)(FSEventStreamRef);
-static void (*pFSEventStreamStop)(FSEventStreamRef);
-
-#define UV__FSEVENTS_PROCESS(handle, block)                                   \
-    do {                                                                      \
-      QUEUE events;                                                           \
-      QUEUE* q;                                                               \
-      uv__fsevents_event_t* event;                                            \
-      int err;                                                                \
-      uv_mutex_lock(&(handle)->cf_mutex);                                     \
-      /* Split-off all events and empty original queue */                     \
-      QUEUE_MOVE(&(handle)->cf_events, &events);                              \
-      /* Get error (if any) and zero original one */                          \
-      err = (handle)->cf_error;                                               \
-      (handle)->cf_error = 0;                                                 \
-      uv_mutex_unlock(&(handle)->cf_mutex);                                   \
-      /* Loop through events, deallocating each after processing */           \
-      while (!QUEUE_EMPTY(&events)) {                                         \
-        q = QUEUE_HEAD(&events);                                              \
-        event = QUEUE_DATA(q, uv__fsevents_event_t, member);                  \
-        QUEUE_REMOVE(q);                                                      \
-        /* NOTE: Checking uv__is_active() is required here, because handle    \
-         * callback may close handle and invoking it after it will lead to    \
-         * incorrect behaviour */                                             \
-        if (!uv__is_closing((handle)) && uv__is_active((handle)))             \
-          block                                                               \
-        /* Free allocated data */                                             \
-        uv__free(event);                                                      \
-      }                                                                       \
-      if (err != 0 && !uv__is_closing((handle)) && uv__is_active((handle)))   \
-        (handle)->cb((handle), NULL, 0, err);                                 \
-    } while (0)
-
-
-/* Runs in UV loop's thread, when there're events to report to handle */
-static void uv__fsevents_cb(uv_async_t* cb) {
-  uv_fs_event_t* handle;
-
-  handle = (uv_fs_event_t*)cb->data;
-
-  UV__FSEVENTS_PROCESS(handle, {
-    handle->cb(handle, event->path[0] ? event->path : NULL, event->events, 0);
-  });
-}
-
-
-/* Runs in CF thread, pushed event into handle's event list */
-static void uv__fsevents_push_event(uv_fs_event_t* handle,
-                                    QUEUE* events,
-                                    int err) {
-  assert(events != NULL || err != 0);
-  uv_mutex_lock(&handle->cf_mutex);
-
-  /* Concatenate two queues */
-  if (events != NULL)
-    QUEUE_ADD(&handle->cf_events, events);
-
-  /* Propagate error */
-  if (err != 0)
-    handle->cf_error = err;
-  uv_mutex_unlock(&handle->cf_mutex);
-
-  uv_async_send(handle->cf_cb);
-}
-
-
-/* Runs in CF thread, when there're events in FSEventStream */
-static void uv__fsevents_event_cb(ConstFSEventStreamRef streamRef,
-                                  void* info,
-                                  size_t numEvents,
-                                  void* eventPaths,
-                                  const FSEventStreamEventFlags eventFlags[],
-                                  const FSEventStreamEventId eventIds[]) {
-  size_t i;
-  int len;
-  char** paths;
-  char* path;
-  char* pos;
-  uv_fs_event_t* handle;
-  QUEUE* q;
-  uv_loop_t* loop;
-  uv__cf_loop_state_t* state;
-  uv__fsevents_event_t* event;
-  FSEventStreamEventFlags flags;
-  QUEUE head;
-
-  loop = (uv_loop_t*)info;
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-  assert(state != NULL);
-  paths = (char**)eventPaths;
-
-  /* For each handle */
-  uv_mutex_lock(&state->fsevent_mutex);
-  QUEUE_FOREACH(q, &state->fsevent_handles) {
-    handle = QUEUE_DATA(q, uv_fs_event_t, cf_member);
-    QUEUE_INIT(&head);
-
-    /* Process and filter out events */
-    for (i = 0; i < numEvents; i++) {
-      flags = eventFlags[i];
-
-      /* Ignore system events */
-      if (flags & kFSEventsSystem)
-        continue;
-
-      path = paths[i];
-      len = strlen(path);
-
-      if (handle->realpath_len == 0)
-        continue; /* This should be unreachable */
-
-      /* Filter out paths that are outside handle's request */
-      if (len < handle->realpath_len)
-        continue;
-
-      if (handle->realpath_len != len &&
-          path[handle->realpath_len] != '/')
-        /* Make sure that realpath actually named a directory,
-         * or that we matched the whole string */
-        continue;
-
-      if (memcmp(path, handle->realpath, handle->realpath_len) != 0)
-        continue;
-
-      if (!(handle->realpath_len == 1 && handle->realpath[0] == '/')) {
-        /* Remove common prefix, unless the watched folder is "/" */
-        path += handle->realpath_len;
-        len -= handle->realpath_len;
-
-        /* Ignore events with path equal to directory itself */
-        if (len <= 1 && (flags & kFSEventStreamEventFlagItemIsDir))
-          continue;
-
-        if (len == 0) {
-          /* Since we're using fsevents to watch the file itself,
-           * realpath == path, and we now need to get the basename of the file back
-           * (for commonality with other codepaths and platforms). */
-          while (len < handle->realpath_len && path[-1] != '/') {
-            path--;
-            len++;
-          }
-          /* Created and Removed seem to be always set, but don't make sense */
-          flags &= ~kFSEventsRenamed;
-        } else {
-          /* Skip forward slash */
-          path++;
-          len--;
-        }
-      }
-
-      /* Do not emit events from subdirectories (without option set) */
-      if ((handle->cf_flags & UV_FS_EVENT_RECURSIVE) == 0 && *path != '\0') {
-        pos = strchr(path + 1, '/');
-        if (pos != NULL)
-          continue;
-      }
-
-      event = (uv__fsevents_event_t*)uv__malloc(sizeof(*event) + len);
-      if (event == NULL)
-        break;
-
-      memset(event, 0, sizeof(*event));
-      memcpy(event->path, path, len + 1);
-      event->events = UV_RENAME;
-
-      if (0 == (flags & kFSEventsRenamed)) {
-        if (0 != (flags & kFSEventsModified) ||
-            0 == (flags & kFSEventStreamEventFlagItemIsDir))
-          event->events = UV_CHANGE;
-      }
-
-      QUEUE_INSERT_TAIL(&head, &event->member);
-    }
-
-    if (!QUEUE_EMPTY(&head))
-      uv__fsevents_push_event(handle, &head, 0);
-  }
-  uv_mutex_unlock(&state->fsevent_mutex);
-}
-
-
-/* Runs in CF thread */
-static int uv__fsevents_create_stream(uv_loop_t* loop, CFArrayRef paths) {
-  uv__cf_loop_state_t* state;
-  FSEventStreamContext ctx;
-  FSEventStreamRef ref;
-  CFAbsoluteTime latency;
-  FSEventStreamCreateFlags flags;
-
-  /* Initialize context */
-  ctx.version = 0;
-  ctx.info = loop;
-  ctx.retain = NULL;
-  ctx.release = NULL;
-  ctx.copyDescription = NULL;
-
-  latency = 0.05;
-
-  /* Explanation of selected flags:
-   * 1. NoDefer - without this flag, events that are happening continuously
-   *    (i.e. each event is happening after time interval less than `latency`,
-   *    counted from previous event), will be deferred and passed to callback
-   *    once they'll either fill whole OS buffer, or when this continuous stream
-   *    will stop (i.e. there'll be delay between events, bigger than
-   *    `latency`).
-   *    Specifying this flag will invoke callback after `latency` time passed
-   *    since event.
-   * 2. FileEvents - fire callback for file changes too (by default it is firing
-   *    it only for directory changes).
-   */
-  flags = kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagFileEvents;
-
-  /*
-   * NOTE: It might sound like a good idea to remember last seen StreamEventId,
-   * but in reality one dir might have last StreamEventId less than, the other,
-   * that is being watched now. Which will cause FSEventStream API to report
-   * changes to files from the past.
-   */
-  ref = pFSEventStreamCreate(NULL,
-                             &uv__fsevents_event_cb,
-                             &ctx,
-                             paths,
-                             kFSEventStreamEventIdSinceNow,
-                             latency,
-                             flags);
-  assert(ref != NULL);
-
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-  pFSEventStreamScheduleWithRunLoop(ref,
-                                    state->loop,
-                                    *pkCFRunLoopDefaultMode);
-  if (!pFSEventStreamStart(ref)) {
-    pFSEventStreamInvalidate(ref);
-    pFSEventStreamRelease(ref);
-    return UV_EMFILE;
-  }
-
-  state->fsevent_stream = ref;
-  return 0;
-}
-
-
-/* Runs in CF thread */
-static void uv__fsevents_destroy_stream(uv_loop_t* loop) {
-  uv__cf_loop_state_t* state;
-
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-
-  if (state->fsevent_stream == NULL)
-    return;
-
-  /* Stop emitting events */
-  pFSEventStreamStop(state->fsevent_stream);
-
-  /* Release stream */
-  pFSEventStreamInvalidate(state->fsevent_stream);
-  pFSEventStreamRelease(state->fsevent_stream);
-  state->fsevent_stream = NULL;
-}
-
-
-/* Runs in CF thread, when there're new fsevent handles to add to stream */
-static void uv__fsevents_reschedule(uv_fs_event_t* handle,
-                                    uv__cf_loop_signal_type_t type) {
-  uv__cf_loop_state_t* state;
-  QUEUE* q;
-  uv_fs_event_t* curr;
-  CFArrayRef cf_paths;
-  CFStringRef* paths;
-  unsigned int i;
-  int err;
-  unsigned int path_count;
-
-  state = (uv__cf_loop_state_t*)handle->loop->cf_state;
-  paths = NULL;
-  cf_paths = NULL;
-  err = 0;
-  /* NOTE: `i` is used in deallocation loop below */
-  i = 0;
-
-  /* Optimization to prevent O(n^2) time spent when starting to watch
-   * many files simultaneously
-   */
-  uv_mutex_lock(&state->fsevent_mutex);
-  if (state->fsevent_need_reschedule == 0) {
-    uv_mutex_unlock(&state->fsevent_mutex);
-    goto final;
-  }
-  state->fsevent_need_reschedule = 0;
-  uv_mutex_unlock(&state->fsevent_mutex);
-
-  /* Destroy previous FSEventStream */
-  uv__fsevents_destroy_stream(handle->loop);
-
-  /* Any failure below will be a memory failure */
-  err = UV_ENOMEM;
-
-  /* Create list of all watched paths */
-  uv_mutex_lock(&state->fsevent_mutex);
-  path_count = state->fsevent_handle_count;
-  if (path_count != 0) {
-    paths = (CFStringRef*)uv__malloc(sizeof(*paths) * path_count);
-    if (paths == NULL) {
-      uv_mutex_unlock(&state->fsevent_mutex);
-      goto final;
-    }
-
-    q = &state->fsevent_handles;
-    for (; i < path_count; i++) {
-      q = QUEUE_NEXT(q);
-      assert(q != &state->fsevent_handles);
-      curr = QUEUE_DATA(q, uv_fs_event_t, cf_member);
-
-      assert(curr->realpath != NULL);
-      paths[i] =
-          pCFStringCreateWithFileSystemRepresentation(NULL, curr->realpath);
-      if (paths[i] == NULL) {
-        uv_mutex_unlock(&state->fsevent_mutex);
-        goto final;
-      }
-    }
-  }
-  uv_mutex_unlock(&state->fsevent_mutex);
-  err = 0;
-
-  if (path_count != 0) {
-    /* Create new FSEventStream */
-    cf_paths = pCFArrayCreate(NULL, (const void**) paths, path_count, NULL);
-    if (cf_paths == NULL) {
-      err = UV_ENOMEM;
-      goto final;
-    }
-    err = uv__fsevents_create_stream(handle->loop, cf_paths);
-  }
-
-final:
-  /* Deallocate all paths in case of failure */
-  if (err != 0) {
-    if (cf_paths == NULL) {
-      while (i != 0)
-        pCFRelease(paths[--i]);
-      uv__free(paths);
-    } else {
-      /* CFArray takes ownership of both strings and original C-array */
-      pCFRelease(cf_paths);
-    }
-
-    /* Broadcast error to all handles */
-    uv_mutex_lock(&state->fsevent_mutex);
-    QUEUE_FOREACH(q, &state->fsevent_handles) {
-      curr = QUEUE_DATA(q, uv_fs_event_t, cf_member);
-      uv__fsevents_push_event(curr, NULL, err);
-    }
-    uv_mutex_unlock(&state->fsevent_mutex);
-  }
-
-  /*
-   * Main thread will block until the removal of handle from the list,
-   * we must tell it when we're ready.
-   *
-   * NOTE: This is coupled with `uv_sem_wait()` in `uv__fsevents_close`
-   */
-  if (type == kUVCFLoopSignalClosing)
-    uv_sem_post(&state->fsevent_sem);
-}
-
-
-static int uv__fsevents_global_init(void) {
-  static pthread_mutex_t global_init_mutex = PTHREAD_MUTEX_INITIALIZER;
-  static void* core_foundation_handle;
-  static void* core_services_handle;
-  int err;
-
-  err = 0;
-  pthread_mutex_lock(&global_init_mutex);
-  if (core_foundation_handle != NULL)
-    goto out;
-
-  /* The libraries are never unloaded because we currently don't have a good
-   * mechanism for keeping a reference count. It's unlikely to be an issue
-   * but if it ever becomes one, we can turn the dynamic library handles into
-   * per-event loop properties and have the dynamic linker keep track for us.
-   */
-  err = UV_ENOSYS;
-  core_foundation_handle = dlopen("/System/Library/Frameworks/"
-                                  "CoreFoundation.framework/"
-                                  "Versions/A/CoreFoundation",
-                                  RTLD_LAZY | RTLD_LOCAL);
-  if (core_foundation_handle == NULL)
-    goto out;
-
-  core_services_handle = dlopen("/System/Library/Frameworks/"
-                                "CoreServices.framework/"
-                                "Versions/A/CoreServices",
-                                RTLD_LAZY | RTLD_LOCAL);
-  if (core_services_handle == NULL)
-    goto out;
-
-  err = UV_ENOENT;
-#define V(handle, symbol)                                                     \
-  do {                                                                        \
-    *(void **)(&p ## symbol) = dlsym((handle), #symbol);                      \
-    if (p ## symbol == NULL)                                                  \
-      goto out;                                                               \
-  }                                                                           \
-  while (0)
-  V(core_foundation_handle, CFArrayCreate);
-  V(core_foundation_handle, CFRelease);
-  V(core_foundation_handle, CFRunLoopAddSource);
-  V(core_foundation_handle, CFRunLoopGetCurrent);
-  V(core_foundation_handle, CFRunLoopRemoveSource);
-  V(core_foundation_handle, CFRunLoopRun);
-  V(core_foundation_handle, CFRunLoopSourceCreate);
-  V(core_foundation_handle, CFRunLoopSourceSignal);
-  V(core_foundation_handle, CFRunLoopStop);
-  V(core_foundation_handle, CFRunLoopWakeUp);
-  V(core_foundation_handle, CFStringCreateWithFileSystemRepresentation);
-  V(core_foundation_handle, CFStringGetSystemEncoding);
-  V(core_foundation_handle, kCFRunLoopDefaultMode);
-  V(core_services_handle, FSEventStreamCreate);
-  V(core_services_handle, FSEventStreamFlushSync);
-  V(core_services_handle, FSEventStreamInvalidate);
-  V(core_services_handle, FSEventStreamRelease);
-  V(core_services_handle, FSEventStreamScheduleWithRunLoop);
-  V(core_services_handle, FSEventStreamStart);
-  V(core_services_handle, FSEventStreamStop);
-#undef V
-  err = 0;
-
-out:
-  if (err && core_services_handle != NULL) {
-    dlclose(core_services_handle);
-    core_services_handle = NULL;
-  }
-
-  if (err && core_foundation_handle != NULL) {
-    dlclose(core_foundation_handle);
-    core_foundation_handle = NULL;
-  }
-
-  pthread_mutex_unlock(&global_init_mutex);
-  return err;
-}
-
-
-/* Runs in UV loop */
-static int uv__fsevents_loop_init(uv_loop_t* loop) {
-  CFRunLoopSourceContext ctx;
-  uv__cf_loop_state_t* state;
-  pthread_attr_t attr_storage;
-  pthread_attr_t* attr;
-  int err;
-
-  if (loop->cf_state != NULL)
-    return 0;
-
-  err = uv__fsevents_global_init();
-  if (err)
-    return err;
-
-  state = (uv__cf_loop_state_t*)uv__calloc(1, sizeof(*state));
-  if (state == NULL)
-    return UV_ENOMEM;
-
-  err = uv_mutex_init(&loop->cf_mutex);
-  if (err)
-    goto fail_mutex_init;
-
-  err = uv_sem_init(&loop->cf_sem, 0);
-  if (err)
-    goto fail_sem_init;
-
-  QUEUE_INIT(&loop->cf_signals);
-
-  err = uv_sem_init(&state->fsevent_sem, 0);
-  if (err)
-    goto fail_fsevent_sem_init;
-
-  err = uv_mutex_init(&state->fsevent_mutex);
-  if (err)
-    goto fail_fsevent_mutex_init;
-
-  QUEUE_INIT(&state->fsevent_handles);
-  state->fsevent_need_reschedule = 0;
-  state->fsevent_handle_count = 0;
-
-  memset(&ctx, 0, sizeof(ctx));
-  ctx.info = loop;
-  ctx.perform = uv__cf_loop_cb;
-  state->signal_source = pCFRunLoopSourceCreate(NULL, 0, &ctx);
-  if (state->signal_source == NULL) {
-    err = UV_ENOMEM;
-    goto fail_signal_source_create;
-  }
-
-  /* In the unlikely event that pthread_attr_init() fails, create the thread
-   * with the default stack size. We'll use a little more address space but
-   * that in itself is not a fatal error.
-   */
-  attr = &attr_storage;
-  if (pthread_attr_init(attr))
-    attr = NULL;
-
-  if (attr != NULL)
-    if (pthread_attr_setstacksize(attr, 4 * PTHREAD_STACK_MIN))
-      abort();
-
-  loop->cf_state = state;
-
-  /* uv_thread_t is an alias for pthread_t. */
-  err = UV__ERR(pthread_create(&loop->cf_thread, attr, uv__cf_loop_runner, loop));
-
-  if (attr != NULL)
-    pthread_attr_destroy(attr);
-
-  if (err)
-    goto fail_thread_create;
-
-  /* Synchronize threads */
-  uv_sem_wait(&loop->cf_sem);
-  return 0;
-
-fail_thread_create:
-  loop->cf_state = NULL;
-
-fail_signal_source_create:
-  uv_mutex_destroy(&state->fsevent_mutex);
-
-fail_fsevent_mutex_init:
-  uv_sem_destroy(&state->fsevent_sem);
-
-fail_fsevent_sem_init:
-  uv_sem_destroy(&loop->cf_sem);
-
-fail_sem_init:
-  uv_mutex_destroy(&loop->cf_mutex);
-
-fail_mutex_init:
-  uv__free(state);
-  return err;
-}
-
-
-/* Runs in UV loop */
-void uv__fsevents_loop_delete(uv_loop_t* loop) {
-  uv__cf_loop_signal_t* s;
-  uv__cf_loop_state_t* state;
-  QUEUE* q;
-
-  if (loop->cf_state == NULL)
-    return;
-
-  if (uv__cf_loop_signal(loop, NULL, kUVCFLoopSignalRegular) != 0)
-    abort();
-
-  uv_thread_join(&loop->cf_thread);
-  uv_sem_destroy(&loop->cf_sem);
-  uv_mutex_destroy(&loop->cf_mutex);
-
-  /* Free any remaining data */
-  while (!QUEUE_EMPTY(&loop->cf_signals)) {
-    q = QUEUE_HEAD(&loop->cf_signals);
-    s = QUEUE_DATA(q, uv__cf_loop_signal_t, member);
-    QUEUE_REMOVE(q);
-    uv__free(s);
-  }
-
-  /* Destroy state */
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-  uv_sem_destroy(&state->fsevent_sem);
-  uv_mutex_destroy(&state->fsevent_mutex);
-  pCFRelease(state->signal_source);
-  uv__free(state);
-  loop->cf_state = NULL;
-}
-
-
-/* Runs in CF thread. This is the CF loop's body */
-static void* uv__cf_loop_runner(void* arg) {
-  uv_loop_t* loop;
-  uv__cf_loop_state_t* state;
-
-  loop = (uv_loop_t*)arg;
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-  state->loop = pCFRunLoopGetCurrent();
-
-  pCFRunLoopAddSource(state->loop,
-                      state->signal_source,
-                      *pkCFRunLoopDefaultMode);
-
-  uv_sem_post(&loop->cf_sem);
-
-  pCFRunLoopRun();
-  pCFRunLoopRemoveSource(state->loop,
-                         state->signal_source,
-                         *pkCFRunLoopDefaultMode);
-
-  return NULL;
-}
-
-
-/* Runs in CF thread, executed after `uv__cf_loop_signal()` */
-static void uv__cf_loop_cb(void* arg) {
-  uv_loop_t* loop;
-  uv__cf_loop_state_t* state;
-  QUEUE* item;
-  QUEUE split_head;
-  uv__cf_loop_signal_t* s;
-
-  loop = (uv_loop_t*)arg;
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-
-  uv_mutex_lock(&loop->cf_mutex);
-  QUEUE_MOVE(&loop->cf_signals, &split_head);
-  uv_mutex_unlock(&loop->cf_mutex);
-
-  while (!QUEUE_EMPTY(&split_head)) {
-    item = QUEUE_HEAD(&split_head);
-    QUEUE_REMOVE(item);
-
-    s = QUEUE_DATA(item, uv__cf_loop_signal_t, member);
-
-    /* This was a termination signal */
-    if (s->handle == NULL)
-      pCFRunLoopStop(state->loop);
-    else
-      uv__fsevents_reschedule(s->handle, s->type);
-
-    uv__free(s);
-  }
-}
-
-
-/* Runs in UV loop to notify CF thread */
-int uv__cf_loop_signal(uv_loop_t* loop,
-                       uv_fs_event_t* handle,
-                       uv__cf_loop_signal_type_t type) {
-  uv__cf_loop_signal_t* item;
-  uv__cf_loop_state_t* state;
-
-  item = (uv__cf_loop_signal_t*)uv__malloc(sizeof(*item));
-  if (item == NULL)
-    return UV_ENOMEM;
-
-  item->handle = handle;
-  item->type = type;
-
-  uv_mutex_lock(&loop->cf_mutex);
-  QUEUE_INSERT_TAIL(&loop->cf_signals, &item->member);
-  uv_mutex_unlock(&loop->cf_mutex);
-
-  state = (uv__cf_loop_state_t*)loop->cf_state;
-  assert(state != NULL);
-  pCFRunLoopSourceSignal(state->signal_source);
-  pCFRunLoopWakeUp(state->loop);
-
-  return 0;
-}
-
-
-/* Runs in UV loop to initialize handle */
-int uv__fsevents_init(uv_fs_event_t* handle) {
-  int err;
-  uv__cf_loop_state_t* state;
-
-  err = uv__fsevents_loop_init(handle->loop);
-  if (err)
-    return err;
-
-  /* Get absolute path to file */
-  handle->realpath = realpath(handle->path, NULL);
-  if (handle->realpath == NULL)
-    return UV__ERR(errno);
-  handle->realpath_len = strlen(handle->realpath);
-
-  /* Initialize event queue */
-  QUEUE_INIT(&handle->cf_events);
-  handle->cf_error = 0;
-
-  /*
-   * Events will occur in other thread.
-   * Initialize callback for getting them back into event loop's thread
-   */
-  handle->cf_cb = (uv_async_t*)uv__malloc(sizeof(*handle->cf_cb));
-  if (handle->cf_cb == NULL) {
-    err = UV_ENOMEM;
-    goto fail_cf_cb_malloc;
-  }
-
-  handle->cf_cb->data = handle;
-  uv_async_init(handle->loop, handle->cf_cb, uv__fsevents_cb);
-  handle->cf_cb->flags |= UV_HANDLE_INTERNAL;
-  uv_unref((uv_handle_t*) handle->cf_cb);
-
-  err = uv_mutex_init(&handle->cf_mutex);
-  if (err)
-    goto fail_cf_mutex_init;
-
-  /* Insert handle into the list */
-  state = (uv__cf_loop_state_t*)handle->loop->cf_state;
-  uv_mutex_lock(&state->fsevent_mutex);
-  QUEUE_INSERT_TAIL(&state->fsevent_handles, &handle->cf_member);
-  state->fsevent_handle_count++;
-  state->fsevent_need_reschedule = 1;
-  uv_mutex_unlock(&state->fsevent_mutex);
-
-  /* Reschedule FSEventStream */
-  assert(handle != NULL);
-  err = uv__cf_loop_signal(handle->loop, handle, kUVCFLoopSignalRegular);
-  if (err)
-    goto fail_loop_signal;
-
-  return 0;
-
-fail_loop_signal:
-  uv_mutex_destroy(&handle->cf_mutex);
-
-fail_cf_mutex_init:
-  uv__free(handle->cf_cb);
-  handle->cf_cb = NULL;
-
-fail_cf_cb_malloc:
-  uv__free(handle->realpath);
-  handle->realpath = NULL;
-  handle->realpath_len = 0;
-
-  return err;
-}
-
-
-/* Runs in UV loop to de-initialize handle */
-int uv__fsevents_close(uv_fs_event_t* handle) {
-  int err;
-  uv__cf_loop_state_t* state;
-
-  if (handle->cf_cb == NULL)
-    return UV_EINVAL;
-
-  /* Remove handle from  the list */
-  state = (uv__cf_loop_state_t*)handle->loop->cf_state;
-  uv_mutex_lock(&state->fsevent_mutex);
-  QUEUE_REMOVE(&handle->cf_member);
-  state->fsevent_handle_count--;
-  state->fsevent_need_reschedule = 1;
-  uv_mutex_unlock(&state->fsevent_mutex);
-
-  /* Reschedule FSEventStream */
-  assert(handle != NULL);
-  err = uv__cf_loop_signal(handle->loop, handle, kUVCFLoopSignalClosing);
-  if (err)
-    return UV__ERR(err);
-
-  /* Wait for deinitialization */
-  uv_sem_wait(&state->fsevent_sem);
-
-  uv_close((uv_handle_t*) handle->cf_cb, (uv_close_cb) uv__free);
-  handle->cf_cb = NULL;
-
-  /* Free data in queue */
-  UV__FSEVENTS_PROCESS(handle, {
-    /* NOP */
-  });
-
-  uv_mutex_destroy(&handle->cf_mutex);
-  uv__free(handle->realpath);
-  handle->realpath = NULL;
-  handle->realpath_len = 0;
-
-  return 0;
-}
-
-#endif /* TARGET_OS_IPHONE */
diff --git a/wpiutil/src/main/native/libuv/src/unix/getaddrinfo.cpp b/wpiutil/src/main/native/libuv/src/unix/getaddrinfo.cpp
deleted file mode 100644
index 9a26b45..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/getaddrinfo.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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.
- */
-
-/* Expose glibc-specific EAI_* error codes. Needs to be defined before we
- * include any headers.
- */
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE
-#endif
-
-#include "uv.h"
-#include "internal.h"
-#include "idna.h"
-
-#include <errno.h>
-#include <stddef.h> /* NULL */
-#include <stdlib.h>
-#include <string.h>
-#include <net/if.h> /* if_indextoname() */
-
-/* EAI_* constants. */
-#include <netdb.h>
-
-
-int uv__getaddrinfo_translate_error(int sys_err) {
-  switch (sys_err) {
-  case 0: return 0;
-#if defined(EAI_ADDRFAMILY)
-  case EAI_ADDRFAMILY: return UV_EAI_ADDRFAMILY;
-#endif
-#if defined(EAI_AGAIN)
-  case EAI_AGAIN: return UV_EAI_AGAIN;
-#endif
-#if defined(EAI_BADFLAGS)
-  case EAI_BADFLAGS: return UV_EAI_BADFLAGS;
-#endif
-#if defined(EAI_BADHINTS)
-  case EAI_BADHINTS: return UV_EAI_BADHINTS;
-#endif
-#if defined(EAI_CANCELED)
-  case EAI_CANCELED: return UV_EAI_CANCELED;
-#endif
-#if defined(EAI_FAIL)
-  case EAI_FAIL: return UV_EAI_FAIL;
-#endif
-#if defined(EAI_FAMILY)
-  case EAI_FAMILY: return UV_EAI_FAMILY;
-#endif
-#if defined(EAI_MEMORY)
-  case EAI_MEMORY: return UV_EAI_MEMORY;
-#endif
-#if defined(EAI_NODATA)
-  case EAI_NODATA: return UV_EAI_NODATA;
-#endif
-#if defined(EAI_NONAME)
-# if !defined(EAI_NODATA) || EAI_NODATA != EAI_NONAME
-  case EAI_NONAME: return UV_EAI_NONAME;
-# endif
-#endif
-#if defined(EAI_OVERFLOW)
-  case EAI_OVERFLOW: return UV_EAI_OVERFLOW;
-#endif
-#if defined(EAI_PROTOCOL)
-  case EAI_PROTOCOL: return UV_EAI_PROTOCOL;
-#endif
-#if defined(EAI_SERVICE)
-  case EAI_SERVICE: return UV_EAI_SERVICE;
-#endif
-#if defined(EAI_SOCKTYPE)
-  case EAI_SOCKTYPE: return UV_EAI_SOCKTYPE;
-#endif
-#if defined(EAI_SYSTEM)
-  case EAI_SYSTEM: return UV__ERR(errno);
-#endif
-  }
-  assert(!"unknown EAI_* error code");
-  abort();
-#ifndef __SUNPRO_C
-  return 0;  /* Pacify compiler. */
-#endif
-}
-
-
-static void uv__getaddrinfo_work(struct uv__work* w) {
-  uv_getaddrinfo_t* req;
-  int err;
-
-  req = container_of(w, uv_getaddrinfo_t, work_req);
-  err = getaddrinfo(req->hostname, req->service, req->hints, &req->addrinfo);
-  req->retcode = uv__getaddrinfo_translate_error(err);
-}
-
-
-static void uv__getaddrinfo_done(struct uv__work* w, int status) {
-  uv_getaddrinfo_t* req;
-
-  req = container_of(w, uv_getaddrinfo_t, work_req);
-  uv__req_unregister(req->loop, req);
-
-  /* See initialization in uv_getaddrinfo(). */
-  if (req->hints)
-    uv__free(req->hints);
-  else if (req->service)
-    uv__free(req->service);
-  else if (req->hostname)
-    uv__free(req->hostname);
-  else
-    assert(0);
-
-  req->hints = NULL;
-  req->service = NULL;
-  req->hostname = NULL;
-
-  if (status == UV_ECANCELED) {
-    assert(req->retcode == 0);
-    req->retcode = UV_EAI_CANCELED;
-  }
-
-  if (req->cb)
-    req->cb(req, req->retcode, req->addrinfo);
-}
-
-
-int uv_getaddrinfo(uv_loop_t* loop,
-                   uv_getaddrinfo_t* req,
-                   uv_getaddrinfo_cb cb,
-                   const char* hostname,
-                   const char* service,
-                   const struct addrinfo* hints) {
-  char hostname_ascii[256];
-  size_t hostname_len;
-  size_t service_len;
-  size_t hints_len;
-  size_t len;
-  char* buf;
-  long rc;
-
-  if (req == NULL || (hostname == NULL && service == NULL))
-    return UV_EINVAL;
-
-  /* FIXME(bnoordhuis) IDNA does not seem to work z/OS,
-   * probably because it uses EBCDIC rather than ASCII.
-   */
-#ifdef __MVS__
-  (void) &hostname_ascii;
-#else
-  if (hostname != NULL) {
-    rc = uv__idna_toascii(hostname,
-                          hostname + strlen(hostname),
-                          hostname_ascii,
-                          hostname_ascii + sizeof(hostname_ascii));
-    if (rc < 0)
-      return rc;
-    hostname = hostname_ascii;
-  }
-#endif
-
-  hostname_len = hostname ? strlen(hostname) + 1 : 0;
-  service_len = service ? strlen(service) + 1 : 0;
-  hints_len = hints ? sizeof(*hints) : 0;
-  buf = (char*)uv__malloc(hostname_len + service_len + hints_len);
-
-  if (buf == NULL)
-    return UV_ENOMEM;
-
-  uv__req_init(loop, req, UV_GETADDRINFO);
-  req->loop = loop;
-  req->cb = cb;
-  req->addrinfo = NULL;
-  req->hints = NULL;
-  req->service = NULL;
-  req->hostname = NULL;
-  req->retcode = 0;
-
-  /* order matters, see uv_getaddrinfo_done() */
-  len = 0;
-
-  if (hints) {
-    req->hints = (struct addrinfo*)memcpy(buf + len, hints, sizeof(*hints));
-    len += sizeof(*hints);
-  }
-
-  if (service) {
-    req->service = (char*)memcpy(buf + len, service, service_len);
-    len += service_len;
-  }
-
-  if (hostname)
-    req->hostname = (char*)memcpy(buf + len, hostname, hostname_len);
-
-  if (cb) {
-    uv__work_submit(loop,
-                    &req->work_req,
-                    UV__WORK_SLOW_IO,
-                    uv__getaddrinfo_work,
-                    uv__getaddrinfo_done);
-    return 0;
-  } else {
-    uv__getaddrinfo_work(&req->work_req);
-    uv__getaddrinfo_done(&req->work_req, 0);
-    return req->retcode;
-  }
-}
-
-
-void uv_freeaddrinfo(struct addrinfo* ai) {
-  if (ai)
-    freeaddrinfo(ai);
-}
-
-
-int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) {
-  char ifname_buf[UV_IF_NAMESIZE];
-  size_t len;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  if (if_indextoname(ifindex, ifname_buf) == NULL)
-    return UV__ERR(errno);
-
-  len = strnlen(ifname_buf, sizeof(ifname_buf));
-
-  if (*size <= len) {
-    *size = len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, ifname_buf, len);
-  buffer[len] = '\0';
-  *size = len;
-
-  return 0;
-}
-
-int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size) {
-  return uv_if_indextoname(ifindex, buffer, size);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/getnameinfo.cpp b/wpiutil/src/main/native/libuv/src/unix/getnameinfo.cpp
deleted file mode 100644
index 991002a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/getnameinfo.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-*
-* 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 <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-static void uv__getnameinfo_work(struct uv__work* w) {
-  uv_getnameinfo_t* req;
-  int err;
-  socklen_t salen;
-
-  req = container_of(w, uv_getnameinfo_t, work_req);
-
-  if (req->storage.ss_family == AF_INET)
-    salen = sizeof(struct sockaddr_in);
-  else if (req->storage.ss_family == AF_INET6)
-    salen = sizeof(struct sockaddr_in6);
-  else
-    abort();
-
-  err = getnameinfo((struct sockaddr*) &req->storage,
-                    salen,
-                    req->host,
-                    sizeof(req->host),
-                    req->service,
-                    sizeof(req->service),
-                    req->flags);
-  req->retcode = uv__getaddrinfo_translate_error(err);
-}
-
-static void uv__getnameinfo_done(struct uv__work* w, int status) {
-  uv_getnameinfo_t* req;
-  char* host;
-  char* service;
-
-  req = container_of(w, uv_getnameinfo_t, work_req);
-  uv__req_unregister(req->loop, req);
-  host = service = NULL;
-
-  if (status == UV_ECANCELED) {
-    assert(req->retcode == 0);
-    req->retcode = UV_EAI_CANCELED;
-  } else if (req->retcode == 0) {
-    host = req->host;
-    service = req->service;
-  }
-
-  if (req->getnameinfo_cb)
-    req->getnameinfo_cb(req, req->retcode, host, service);
-}
-
-/*
-* Entry point for getnameinfo
-* return 0 if a callback will be made
-* return error code if validation fails
-*/
-int uv_getnameinfo(uv_loop_t* loop,
-                   uv_getnameinfo_t* req,
-                   uv_getnameinfo_cb getnameinfo_cb,
-                   const struct sockaddr* addr,
-                   int flags) {
-  if (req == NULL || addr == NULL)
-    return UV_EINVAL;
-
-  if (addr->sa_family == AF_INET) {
-    memcpy(&req->storage,
-           addr,
-           sizeof(struct sockaddr_in));
-  } else if (addr->sa_family == AF_INET6) {
-    memcpy(&req->storage,
-           addr,
-           sizeof(struct sockaddr_in6));
-  } else {
-    return UV_EINVAL;
-  }
-
-  uv__req_init(loop, (uv_req_t*)req, UV_GETNAMEINFO);
-
-  req->getnameinfo_cb = getnameinfo_cb;
-  req->flags = flags;
-  req->type = UV_GETNAMEINFO;
-  req->loop = loop;
-  req->retcode = 0;
-
-  if (getnameinfo_cb) {
-    uv__work_submit(loop,
-                    &req->work_req,
-                    UV__WORK_SLOW_IO,
-                    uv__getnameinfo_work,
-                    uv__getnameinfo_done);
-    return 0;
-  } else {
-    uv__getnameinfo_work(&req->work_req);
-    uv__getnameinfo_done(&req->work_req, 0);
-    return req->retcode;
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/ibmi.cpp b/wpiutil/src/main/native/libuv/src/unix/ibmi.cpp
deleted file mode 100644
index 4b0be2d..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/ibmi.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <net/if.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#include <sys/time.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <utmp.h>
-#include <libgen.h>
-
-#include <sys/protosw.h>
-#include <procinfo.h>
-#include <sys/proc.h>
-#include <sys/procfs.h>
-
-#include <ctype.h>
-
-#include <sys/mntctl.h>
-#include <sys/vmount.h>
-#include <limits.h>
-#include <strings.h>
-#include <sys/vnode.h>
-
-#include <as400_protos.h>
-
-
-typedef struct {
-  int bytes_available;
-  int bytes_returned;
-  char current_date_and_time[8];
-  char system_name[8];
-  char elapsed_time[6];
-  char restricted_state_flag;
-  char reserved;
-  int percent_processing_unit_used;
-  int jobs_in_system;
-  int percent_permanent_addresses;
-  int percent_temporary_addresses;
-  int system_asp;
-  int percent_system_asp_used;
-  int total_auxiliary_storage;
-  int current_unprotected_storage_used;
-  int maximum_unprotected_storage_used;
-  int percent_db_capability;
-  int main_storage_size;
-  int number_of_partitions;
-  int partition_identifier;
-  int reserved1;
-  int current_processing_capacity;
-  char processor_sharing_attribute;
-  char reserved2[3];
-  int number_of_processors;
-  int active_jobs_in_system;
-  int active_threads_in_system;
-  int maximum_jobs_in_system;
-  int percent_temporary_256mb_segments_used;
-  int percent_temporary_4gb_segments_used;
-  int percent_permanent_256mb_segments_used;
-  int percent_permanent_4gb_segments_used;
-  int percent_current_interactive_performance;
-  int percent_uncapped_cpu_capacity_used;
-  int percent_shared_processor_pool_used;
-  long main_storage_size_long;
-} SSTS0200;
-
-
-static int get_ibmi_system_status(SSTS0200* rcvr) {
-  /* rcvrlen is input parameter 2 to QWCRSSTS */
-  unsigned int rcvrlen = sizeof(*rcvr);
-
-  /* format is input parameter 3 to QWCRSSTS ("SSTS0200" in EBCDIC) */
-  unsigned char format[] = {0xE2, 0xE2, 0xE3, 0xE2, 0xF0, 0xF2, 0xF0, 0xF0};
-
-  /* reset_status is input parameter 4 to QWCRSSTS ("*NO       " in EBCDIC) */
-  unsigned char reset_status[] = {
-    0x5C, 0xD5, 0xD6, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
-  };
-
-  /* errcode is input parameter 5 to QWCRSSTS */
-  struct _errcode {
-    int bytes_provided;
-    int bytes_available;
-    char msgid[7];
-  } errcode;
-
-  /* qwcrssts_pointer is the 16-byte tagged system pointer to QWCRSSTS */
-  ILEpointer __attribute__((aligned(16))) qwcrssts_pointer;
-
-  /* qwcrssts_argv is the array of argument pointers to QWCRSSTS */
-  void* qwcrssts_argv[6];
-
-  /* Set the IBM i pointer to the QSYS/QWCRSSTS *PGM object */
-  int rc = _RSLOBJ2(&qwcrssts_pointer, RSLOBJ_TS_PGM, "QWCRSSTS", "QSYS");
-
-  if (rc != 0)
-    return rc;
-
-  /* initialize the QWCRSSTS returned info structure */
-  memset(rcvr, 0, sizeof(*rcvr));
-
-  /* initialize the QWCRSSTS error code structure */
-  memset(&errcode, 0, sizeof(errcode));
-  errcode.bytes_provided = sizeof(errcode);
-
-  /* initialize the array of argument pointers for the QWCRSSTS API */
-  qwcrssts_argv[0] = rcvr;
-  qwcrssts_argv[1] = &rcvrlen;
-  qwcrssts_argv[2] = &format;
-  qwcrssts_argv[3] = &reset_status;
-  qwcrssts_argv[4] = &errcode;
-  qwcrssts_argv[5] = NULL;
-
-  /* Call the IBM i QWCRSSTS API from PASE */
-  rc = _PGMCALL(&qwcrssts_pointer, (void**)&qwcrssts_argv, 0);
-
-  return rc;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  SSTS0200 rcvr;
-
-  if (get_ibmi_system_status(&rcvr))
-    return 0;
-
-  /* The amount of main storage, in kilobytes, in the system. */
-  uint64_t main_storage_size = rcvr.main_storage_size;
-
-  /* The current amount of storage in use for temporary objects.
-   * in millions (M) of bytes.
-   */
-  uint64_t current_unprotected_storage_used =
-    rcvr.current_unprotected_storage_used * 1024ULL;
-
-  uint64_t free_storage_size =
-    (main_storage_size - current_unprotected_storage_used) * 1024ULL;
-
-  return free_storage_size < 0 ? 0 : free_storage_size;
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  SSTS0200 rcvr;
-
-  if (get_ibmi_system_status(&rcvr))
-    return 0;
-
-  return (uint64_t)rcvr.main_storage_size * 1024ULL;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-void uv_loadavg(double avg[3]) {
-  SSTS0200 rcvr;
-
-  if (get_ibmi_system_status(&rcvr)) {
-    avg[0] = avg[1] = avg[2] = 0;
-    return;
-  }
-
-  /* The average (in tenths) of the elapsed time during which the processing
-   * units were in use. For example, a value of 411 in binary would be 41.1%.
-   * This percentage could be greater than 100% for an uncapped partition.
-   */
-  double processing_unit_used_percent =
-    rcvr.percent_processing_unit_used / 1000.0;
-
-  avg[0] = avg[1] = avg[2] = processing_unit_used_percent;
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  *rss = 0;
-  return 0;
-}
-
-
-int uv_uptime(double* uptime) {
-  return UV_ENOSYS;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int numcpus, idx = 0;
-  uv_cpu_info_t* cpu_info;
-
-  *cpu_infos = NULL;
-  *count = 0;
-
-  numcpus = sysconf(_SC_NPROCESSORS_ONLN);
-
-  *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(uv_cpu_info_t));
-  if (!*cpu_infos) {
-    return UV_ENOMEM;
-  }
-
-  cpu_info = *cpu_infos;
-  for (idx = 0; idx < numcpus; idx++) {
-    cpu_info->speed = 0;
-    cpu_info->model = uv__strdup("unknown");
-    cpu_info->cpu_times.user = 0;
-    cpu_info->cpu_times.sys = 0;
-    cpu_info->cpu_times.idle = 0;
-    cpu_info->cpu_times.irq = 0;
-    cpu_info->cpu_times.nice = 0;
-    cpu_info++;
-  }
-  *count = numcpus;
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/internal.h b/wpiutil/src/main/native/libuv/src/unix/internal.h
deleted file mode 100644
index 13ca2e6..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/internal.h
+++ /dev/null
@@ -1,329 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_UNIX_INTERNAL_H_
-#define UV_UNIX_INTERNAL_H_
-
-#include "uv-common.h"
-
-#include <assert.h>
-#include <limits.h> /* _POSIX_PATH_MAX, PATH_MAX */
-#include <stdlib.h> /* abort */
-#include <string.h> /* strrchr */
-#include <fcntl.h>  /* O_CLOEXEC, may be */
-#include <stdio.h>
-#include <errno.h>
-
-#if defined(__STRICT_ANSI__)
-# define inline __inline
-#endif
-
-#if defined(__linux__)
-# include "linux-syscalls.h"
-#endif /* __linux__ */
-
-#if defined(__MVS__)
-# include "os390-syscalls.h"
-#endif /* __MVS__ */
-
-#if defined(__sun)
-# include <sys/port.h>
-# include <port.h>
-#endif /* __sun */
-
-#if defined(_AIX)
-# define reqevents events
-# define rtnevents revents
-# include <sys/poll.h>
-#else
-# include <poll.h>
-#endif /* _AIX */
-
-#if defined(__APPLE__) && !TARGET_OS_IPHONE
-# include <AvailabilityMacros.h>
-#endif
-
-#if defined(_POSIX_PATH_MAX)
-# define UV__PATH_MAX _POSIX_PATH_MAX
-#elif defined(PATH_MAX)
-# define UV__PATH_MAX PATH_MAX
-#else
-# define UV__PATH_MAX 8192
-#endif
-
-#if defined(__ANDROID__)
-int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset);
-# ifdef pthread_sigmask
-# undef pthread_sigmask
-# endif
-# define pthread_sigmask(how, set, oldset) uv__pthread_sigmask(how, set, oldset)
-#endif
-
-#define ACCESS_ONCE(type, var)                                                \
-  (*(volatile type*) &(var))
-
-#define ROUND_UP(a, b)                                                        \
-  ((a) % (b) ? ((a) + (b)) - ((a) % (b)) : (a))
-
-#define UNREACHABLE()                                                         \
-  do {                                                                        \
-    assert(0 && "unreachable code");                                          \
-    abort();                                                                  \
-  }                                                                           \
-  while (0)
-
-#define SAVE_ERRNO(block)                                                     \
-  do {                                                                        \
-    int _saved_errno = errno;                                                 \
-    do { block; } while (0);                                                  \
-    errno = _saved_errno;                                                     \
-  }                                                                           \
-  while (0)
-
-/* The __clang__ and __INTEL_COMPILER checks are superfluous because they
- * define __GNUC__. They are here to convey to you, dear reader, that these
- * macros are enabled when compiling with clang or icc.
- */
-#if defined(__clang__) ||                                                     \
-    defined(__GNUC__) ||                                                      \
-    defined(__INTEL_COMPILER)
-# define UV_DESTRUCTOR(declaration) __attribute__((destructor)) declaration
-# define UV_UNUSED(declaration)     __attribute__((unused)) declaration
-#else
-# define UV_DESTRUCTOR(declaration) declaration
-# define UV_UNUSED(declaration)     declaration
-#endif
-
-/* Leans on the fact that, on Linux, POLLRDHUP == EPOLLRDHUP. */
-#ifdef POLLRDHUP
-# define UV__POLLRDHUP POLLRDHUP
-#else
-# define UV__POLLRDHUP 0x2000
-#endif
-
-#ifdef POLLPRI
-# define UV__POLLPRI POLLPRI
-#else
-# define UV__POLLPRI 0
-#endif
-
-#if !defined(O_CLOEXEC) && defined(__FreeBSD__)
-/*
- * It may be that we are just missing `__POSIX_VISIBLE >= 200809`.
- * Try using fixed value const and give up, if it doesn't work
- */
-# define O_CLOEXEC 0x00100000
-#endif
-
-typedef struct uv__stream_queued_fds_s uv__stream_queued_fds_t;
-
-/* loop flags */
-enum {
-  UV_LOOP_BLOCK_SIGPROF = 1
-};
-
-/* flags of excluding ifaddr */
-enum {
-  UV__EXCLUDE_IFPHYS,
-  UV__EXCLUDE_IFADDR
-};
-
-typedef enum {
-  UV_CLOCK_PRECISE = 0,  /* Use the highest resolution clock available. */
-  UV_CLOCK_FAST = 1      /* Use the fastest clock with <= 1ms granularity. */
-} uv_clocktype_t;
-
-struct uv__stream_queued_fds_s {
-  unsigned int size;
-  unsigned int offset;
-  int fds[1];
-};
-
-
-#if defined(_AIX) || \
-    defined(__APPLE__) || \
-    defined(__DragonFly__) || \
-    defined(__FreeBSD__) || \
-    defined(__FreeBSD_kernel__) || \
-    defined(__linux__) || \
-    defined(__OpenBSD__) || \
-    defined(__NetBSD__)
-#define uv__cloexec uv__cloexec_ioctl
-#define uv__nonblock uv__nonblock_ioctl
-#define UV__NONBLOCK_IS_IOCTL
-#else
-#define uv__cloexec uv__cloexec_fcntl
-#define uv__nonblock uv__nonblock_fcntl
-#define UV__NONBLOCK_IS_FCNTL
-#endif
-
-/* On Linux, uv__nonblock_fcntl() and uv__nonblock_ioctl() do not commute
- * when O_NDELAY is not equal to O_NONBLOCK.  Case in point: linux/sparc32
- * and linux/sparc64, where O_NDELAY is O_NONBLOCK + another bit.
- *
- * Libuv uses uv__nonblock_fcntl() directly sometimes so ensure that it
- * commutes with uv__nonblock().
- */
-#if defined(__linux__) && O_NDELAY != O_NONBLOCK
-#undef uv__nonblock
-#define uv__nonblock uv__nonblock_fcntl
-#undef UV__NONBLOCK_IS_IOCTL
-#define UV__NONBLOCK_IS_FCNTL
-#endif
-
-/* core */
-int uv__cloexec_ioctl(int fd, int set);
-int uv__cloexec_fcntl(int fd, int set);
-int uv__nonblock_ioctl(int fd, int set);
-int uv__nonblock_fcntl(int fd, int set);
-int uv__close(int fd); /* preserves errno */
-int uv__close_nocheckstdio(int fd);
-int uv__close_nocancel(int fd);
-int uv__socket(int domain, int type, int protocol);
-ssize_t uv__recvmsg(int fd, struct msghdr *msg, int flags);
-void uv__make_close_pending(uv_handle_t* handle);
-int uv__getiovmax(void);
-
-void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd);
-void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events);
-void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events);
-void uv__io_close(uv_loop_t* loop, uv__io_t* w);
-void uv__io_feed(uv_loop_t* loop, uv__io_t* w);
-int uv__io_active(const uv__io_t* w, unsigned int events);
-int uv__io_check_fd(uv_loop_t* loop, int fd);
-void uv__io_poll(uv_loop_t* loop, int timeout); /* in milliseconds or -1 */
-int uv__io_fork(uv_loop_t* loop);
-int uv__fd_exists(uv_loop_t* loop, int fd);
-
-/* async */
-void uv__async_stop(uv_loop_t* loop);
-int uv__async_fork(uv_loop_t* loop);
-
-
-/* loop */
-void uv__run_idle(uv_loop_t* loop);
-void uv__run_check(uv_loop_t* loop);
-void uv__run_prepare(uv_loop_t* loop);
-
-/* stream */
-void uv__stream_init(uv_loop_t* loop, uv_stream_t* stream,
-    uv_handle_type type);
-int uv__stream_open(uv_stream_t*, int fd, int flags);
-void uv__stream_destroy(uv_stream_t* stream);
-#if defined(__APPLE__)
-int uv__stream_try_select(uv_stream_t* stream, int* fd);
-#endif /* defined(__APPLE__) */
-void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events);
-int uv__accept(int sockfd);
-int uv__dup2_cloexec(int oldfd, int newfd);
-int uv__open_cloexec(const char* path, int flags);
-
-/* tcp */
-int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb);
-int uv__tcp_nodelay(int fd, int on);
-int uv__tcp_keepalive(int fd, int on, unsigned int delay);
-
-/* pipe */
-int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
-
-/* signal */
-void uv__signal_close(uv_signal_t* handle);
-void uv__signal_global_once_init(void);
-void uv__signal_loop_cleanup(uv_loop_t* loop);
-int uv__signal_loop_fork(uv_loop_t* loop);
-
-/* platform specific */
-uint64_t uv__hrtime(uv_clocktype_t type);
-int uv__kqueue_init(uv_loop_t* loop);
-int uv__platform_loop_init(uv_loop_t* loop);
-void uv__platform_loop_delete(uv_loop_t* loop);
-void uv__platform_invalidate_fd(uv_loop_t* loop, int fd);
-
-/* various */
-void uv__async_close(uv_async_t* handle);
-void uv__check_close(uv_check_t* handle);
-void uv__fs_event_close(uv_fs_event_t* handle);
-void uv__idle_close(uv_idle_t* handle);
-void uv__pipe_close(uv_pipe_t* handle);
-void uv__poll_close(uv_poll_t* handle);
-void uv__prepare_close(uv_prepare_t* handle);
-void uv__process_close(uv_process_t* handle);
-void uv__stream_close(uv_stream_t* handle);
-void uv__tcp_close(uv_tcp_t* handle);
-void uv__udp_close(uv_udp_t* handle);
-void uv__udp_finish_close(uv_udp_t* handle);
-uv_handle_type uv__handle_type(int fd);
-FILE* uv__open_file(const char* path);
-int uv__getpwuid_r(uv_passwd_t* pwd);
-
-
-#if defined(__APPLE__)
-int uv___stream_fd(const uv_stream_t* handle);
-#define uv__stream_fd(handle) (uv___stream_fd((const uv_stream_t*) (handle)))
-#else
-#define uv__stream_fd(handle) ((handle)->io_watcher.fd)
-#endif /* defined(__APPLE__) */
-
-#ifdef UV__O_NONBLOCK
-# define UV__F_NONBLOCK UV__O_NONBLOCK
-#else
-# define UV__F_NONBLOCK 1
-#endif
-
-int uv__make_socketpair(int fds[2], int flags);
-int uv__make_pipe(int fds[2], int flags);
-
-#if defined(__APPLE__)
-
-int uv__fsevents_init(uv_fs_event_t* handle);
-int uv__fsevents_close(uv_fs_event_t* handle);
-void uv__fsevents_loop_delete(uv_loop_t* loop);
-
-#endif /* defined(__APPLE__) */
-
-UV_UNUSED(static void uv__update_time(uv_loop_t* loop)) {
-  /* Use a fast time source if available.  We only need millisecond precision.
-   */
-  loop->time = uv__hrtime(UV_CLOCK_FAST) / 1000000;
-}
-
-UV_UNUSED(static const char* uv__basename_r(const char* path)) {
-  const char* s;
-
-  s = strrchr(path, '/');
-  if (s == NULL)
-    return (char*) path;
-
-  return s + 1;
-}
-
-#if defined(__linux__)
-int uv__inotify_fork(uv_loop_t* loop, void* old_watchers);
-#endif
-
-typedef int (*uv__peersockfunc)(int, struct sockaddr*, socklen_t*);
-
-int uv__getsockpeername(const uv_handle_t* handle,
-                        uv__peersockfunc func,
-                        struct sockaddr* name,
-                        int* namelen);
-
-#endif /* UV_UNIX_INTERNAL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/unix/kqueue.cpp b/wpiutil/src/main/native/libuv/src/unix/kqueue.cpp
deleted file mode 100644
index 4c4268b..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/kqueue.cpp
+++ /dev/null
@@ -1,536 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/time.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <time.h>
-
-/*
- * Required on
- * - Until at least FreeBSD 11.0
- * - Older versions of Mac OS X
- *
- * http://www.boost.org/doc/libs/1_61_0/boost/asio/detail/kqueue_reactor.hpp
- */
-#ifndef EV_OOBAND
-#define EV_OOBAND  EV_FLAG1
-#endif
-
-static void uv__fs_event(uv_loop_t* loop, uv__io_t* w, unsigned int fflags);
-
-
-int uv__kqueue_init(uv_loop_t* loop) {
-  loop->backend_fd = kqueue();
-  if (loop->backend_fd == -1)
-    return UV__ERR(errno);
-
-  uv__cloexec(loop->backend_fd, 1);
-
-  return 0;
-}
-
-
-#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-static int uv__has_forked_with_cfrunloop;
-#endif
-
-int uv__io_fork(uv_loop_t* loop) {
-  int err;
-  loop->backend_fd = -1;
-  err = uv__kqueue_init(loop);
-  if (err)
-    return err;
-
-#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-  if (loop->cf_state != NULL) {
-    /* We cannot start another CFRunloop and/or thread in the child
-       process; CF aborts if you try or if you try to touch the thread
-       at all to kill it. So the best we can do is ignore it from now
-       on. This means we can't watch directories in the same way
-       anymore (like other BSDs). It also means we cannot properly
-       clean up the allocated resources; calling
-       uv__fsevents_loop_delete from uv_loop_close will crash the
-       process. So we sidestep the issue by pretending like we never
-       started it in the first place.
-    */
-    uv__has_forked_with_cfrunloop = 1;
-    uv__free(loop->cf_state);
-    loop->cf_state = NULL;
-  }
-#endif /* #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
-  return err;
-}
-
-
-int uv__io_check_fd(uv_loop_t* loop, int fd) {
-  struct kevent ev;
-  int rc;
-
-  rc = 0;
-  EV_SET(&ev, fd, EVFILT_READ, EV_ADD, 0, 0, 0);
-  if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
-    rc = UV__ERR(errno);
-
-  EV_SET(&ev, fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
-  if (rc == 0)
-    if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
-      abort();
-
-  return rc;
-}
-
-
-void uv__io_poll(uv_loop_t* loop, int timeout) {
-  struct kevent events[1024];
-  struct kevent* ev;
-  struct timespec spec;
-  unsigned int nevents;
-  unsigned int revents;
-  QUEUE* q;
-  uv__io_t* w;
-  sigset_t* pset;
-  sigset_t set;
-  uint64_t base;
-  uint64_t diff;
-  int have_signals;
-  int filter;
-  int fflags;
-  int count;
-  int nfds;
-  int fd;
-  int op;
-  int i;
-
-  if (loop->nfds == 0) {
-    assert(QUEUE_EMPTY(&loop->watcher_queue));
-    return;
-  }
-
-  nevents = 0;
-
-  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
-    q = QUEUE_HEAD(&loop->watcher_queue);
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);
-
-    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
-    assert(w->pevents != 0);
-    assert(w->fd >= 0);
-    assert(w->fd < (int) loop->nwatchers);
-
-    if ((w->events & POLLIN) == 0 && (w->pevents & POLLIN) != 0) {
-      filter = EVFILT_READ;
-      fflags = 0;
-      op = EV_ADD;
-
-      if (w->cb == uv__fs_event) {
-        filter = EVFILT_VNODE;
-        fflags = NOTE_ATTRIB | NOTE_WRITE  | NOTE_RENAME
-               | NOTE_DELETE | NOTE_EXTEND | NOTE_REVOKE;
-        op = EV_ADD | EV_ONESHOT; /* Stop the event from firing repeatedly. */
-      }
-
-      EV_SET(events + nevents, w->fd, filter, op, fflags, 0, 0);
-
-      if (++nevents == ARRAY_SIZE(events)) {
-        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
-          abort();
-        nevents = 0;
-      }
-    }
-
-    if ((w->events & POLLOUT) == 0 && (w->pevents & POLLOUT) != 0) {
-      EV_SET(events + nevents, w->fd, EVFILT_WRITE, EV_ADD, 0, 0, 0);
-
-      if (++nevents == ARRAY_SIZE(events)) {
-        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
-          abort();
-        nevents = 0;
-      }
-    }
-
-   if ((w->events & UV__POLLPRI) == 0 && (w->pevents & UV__POLLPRI) != 0) {
-      EV_SET(events + nevents, w->fd, EV_OOBAND, EV_ADD, 0, 0, 0);
-
-      if (++nevents == ARRAY_SIZE(events)) {
-        if (kevent(loop->backend_fd, events, nevents, NULL, 0, NULL))
-          abort();
-        nevents = 0;
-      }
-    }
-
-    w->events = w->pevents;
-  }
-
-  pset = NULL;
-  if (loop->flags & UV_LOOP_BLOCK_SIGPROF) {
-    pset = &set;
-    sigemptyset(pset);
-    sigaddset(pset, SIGPROF);
-  }
-
-  assert(timeout >= -1);
-  base = loop->time;
-  count = 48; /* Benchmarks suggest this gives the best throughput. */
-
-  for (;; nevents = 0) {
-    if (timeout != -1) {
-      spec.tv_sec = timeout / 1000;
-      spec.tv_nsec = (timeout % 1000) * 1000000;
-    }
-
-    if (pset != NULL)
-      pthread_sigmask(SIG_BLOCK, pset, NULL);
-
-    nfds = kevent(loop->backend_fd,
-                  events,
-                  nevents,
-                  events,
-                  ARRAY_SIZE(events),
-                  timeout == -1 ? NULL : &spec);
-
-    if (pset != NULL)
-      pthread_sigmask(SIG_UNBLOCK, pset, NULL);
-
-    /* Update loop->time unconditionally. It's tempting to skip the update when
-     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
-     * operating system didn't reschedule our process while in the syscall.
-     */
-    SAVE_ERRNO(uv__update_time(loop));
-
-    if (nfds == 0) {
-      assert(timeout != -1);
-      return;
-    }
-
-    if (nfds == -1) {
-      if (errno != EINTR)
-        abort();
-
-      if (timeout == 0)
-        return;
-
-      if (timeout == -1)
-        continue;
-
-      /* Interrupted by a signal. Update timeout and poll again. */
-      goto update_timeout;
-    }
-
-    have_signals = 0;
-    nevents = 0;
-
-    assert(loop->watchers != NULL);
-    loop->watchers[loop->nwatchers] = (uv__io_t*) events;
-    loop->watchers[loop->nwatchers + 1] = (uv__io_t*) (uintptr_t) nfds;
-    for (i = 0; i < nfds; i++) {
-      ev = events + i;
-      fd = ev->ident;
-      /* Skip invalidated events, see uv__platform_invalidate_fd */
-      if (fd == -1)
-        continue;
-      w = (uv__io_t*)loop->watchers[fd];
-
-      if (w == NULL) {
-        /* File descriptor that we've stopped watching, disarm it.
-         * TODO: batch up. */
-        struct kevent events[1];
-
-        EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
-        if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
-          if (errno != EBADF && errno != ENOENT)
-            abort();
-
-        continue;
-      }
-
-      if (ev->filter == EVFILT_VNODE) {
-        assert(w->events == POLLIN);
-        assert(w->pevents == POLLIN);
-        w->cb(loop, w, ev->fflags); /* XXX always uv__fs_event() */
-        nevents++;
-        continue;
-      }
-
-      revents = 0;
-
-      if (ev->filter == EVFILT_READ) {
-        if (w->pevents & POLLIN) {
-          revents |= POLLIN;
-          w->rcount = ev->data;
-        } else {
-          /* TODO batch up */
-          struct kevent events[1];
-          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
-          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
-            if (errno != ENOENT)
-              abort();
-        }
-      }
-
-      if (ev->filter == EV_OOBAND) {
-        if (w->pevents & UV__POLLPRI) {
-          revents |= UV__POLLPRI;
-          w->rcount = ev->data;
-        } else {
-          /* TODO batch up */
-          struct kevent events[1];
-          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
-          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
-            if (errno != ENOENT)
-              abort();
-        }
-      }
-
-      if (ev->filter == EVFILT_WRITE) {
-        if (w->pevents & POLLOUT) {
-          revents |= POLLOUT;
-          w->wcount = ev->data;
-        } else {
-          /* TODO batch up */
-          struct kevent events[1];
-          EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0);
-          if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL))
-            if (errno != ENOENT)
-              abort();
-        }
-      }
-
-      if (ev->flags & EV_ERROR)
-        revents |= POLLERR;
-
-      if ((ev->flags & EV_EOF) && (w->pevents & UV__POLLRDHUP))
-        revents |= UV__POLLRDHUP;
-
-      if (revents == 0)
-        continue;
-
-      /* Run signal watchers last.  This also affects child process watchers
-       * because those are implemented in terms of signal watchers.
-       */
-      if (w == &loop->signal_io_watcher)
-        have_signals = 1;
-      else
-        w->cb(loop, w, revents);
-
-      nevents++;
-    }
-
-    if (have_signals != 0)
-      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
-
-    loop->watchers[loop->nwatchers] = NULL;
-    loop->watchers[loop->nwatchers + 1] = NULL;
-
-    if (have_signals != 0)
-      return;  /* Event loop should cycle now so don't poll again. */
-
-    if (nevents != 0) {
-      if (nfds == ARRAY_SIZE(events) && --count != 0) {
-        /* Poll for more events but don't block this time. */
-        timeout = 0;
-        continue;
-      }
-      return;
-    }
-
-    if (timeout == 0)
-      return;
-
-    if (timeout == -1)
-      continue;
-
-update_timeout:
-    assert(timeout > 0);
-
-    diff = loop->time - base;
-    if (diff >= (uint64_t) timeout)
-      return;
-
-    timeout -= diff;
-  }
-}
-
-
-void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) {
-  struct kevent* events;
-  uintptr_t i;
-  uintptr_t nfds;
-
-  assert(loop->watchers != NULL);
-  assert(fd >= 0);
-
-  events = (struct kevent*) loop->watchers[loop->nwatchers];
-  nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1];
-  if (events == NULL)
-    return;
-
-  /* Invalidate events with same file descriptor */
-  for (i = 0; i < nfds; i++)
-    if ((int) events[i].ident == fd)
-      events[i].ident = -1;
-}
-
-
-static void uv__fs_event(uv_loop_t* loop, uv__io_t* w, unsigned int fflags) {
-  uv_fs_event_t* handle;
-  struct kevent ev;
-  int events;
-  const char* path;
-#if defined(F_GETPATH)
-  /* MAXPATHLEN == PATH_MAX but the former is what XNU calls it internally. */
-  char pathbuf[MAXPATHLEN];
-#endif
-
-  handle = container_of(w, uv_fs_event_t, event_watcher);
-
-  if (fflags & (NOTE_ATTRIB | NOTE_EXTEND))
-    events = UV_CHANGE;
-  else
-    events = UV_RENAME;
-
-  path = NULL;
-#if defined(F_GETPATH)
-  /* Also works when the file has been unlinked from the file system. Passing
-   * in the path when the file has been deleted is arguably a little strange
-   * but it's consistent with what the inotify backend does.
-   */
-  if (fcntl(handle->event_watcher.fd, F_GETPATH, pathbuf) == 0)
-    path = uv__basename_r(pathbuf);
-#endif
-  handle->cb(handle, path, events, 0);
-
-  if (handle->event_watcher.fd == -1)
-    return;
-
-  /* Watcher operates in one-shot mode, re-arm it. */
-  fflags = NOTE_ATTRIB | NOTE_WRITE  | NOTE_RENAME
-         | NOTE_DELETE | NOTE_EXTEND | NOTE_REVOKE;
-
-  EV_SET(&ev, w->fd, EVFILT_VNODE, EV_ADD | EV_ONESHOT, fflags, 0, 0);
-
-  if (kevent(loop->backend_fd, &ev, 1, NULL, 0, NULL))
-    abort();
-}
-
-
-int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
-  return 0;
-}
-
-
-int uv_fs_event_start(uv_fs_event_t* handle,
-                      uv_fs_event_cb cb,
-                      const char* path,
-                      unsigned int flags) {
-  int fd;
-
-  if (uv__is_active(handle))
-    return UV_EINVAL;
-
-#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-  /* Nullify field to perform checks later */
-  handle->cf_cb = NULL;
-  handle->realpath = NULL;
-  handle->realpath_len = 0;
-  handle->cf_flags = flags;
-
-  if (!uv__has_forked_with_cfrunloop) {
-    int r;
-    /* The fallback fd is not used */
-    handle->event_watcher.fd = -1;
-    handle->path = uv__strdup(path);
-    if (handle->path == NULL)
-      return UV_ENOMEM;
-    handle->cb = cb;
-    r = uv__fsevents_init(handle);
-    if (r == 0) {
-      uv__handle_start(handle);
-    } else {
-      uv__free(handle->path);
-      handle->path = NULL;
-    }
-    return r;
-  }
-#endif /* #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */
-
-  /* TODO open asynchronously - but how do we report back errors? */
-  fd = open(path, O_RDONLY);
-  if (fd == -1)
-    return UV__ERR(errno);
-
-  handle->path = uv__strdup(path);
-  if (handle->path == NULL) {
-    uv__close_nocheckstdio(fd);
-    return UV_ENOMEM;
-  }
-
-  handle->cb = cb;
-  uv__handle_start(handle);
-  uv__io_init(&handle->event_watcher, uv__fs_event, fd);
-  uv__io_start(handle->loop, &handle->event_watcher, POLLIN);
-
-  return 0;
-}
-
-
-int uv_fs_event_stop(uv_fs_event_t* handle) {
-  int r;
-  r = 0;
-
-  if (!uv__is_active(handle))
-    return 0;
-
-  uv__handle_stop(handle);
-
-#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-  if (!uv__has_forked_with_cfrunloop)
-    r = uv__fsevents_close(handle);
-#endif
-
-  if (handle->event_watcher.fd != -1) {
-    uv__io_close(handle->loop, &handle->event_watcher);
-    uv__close(handle->event_watcher.fd);
-    handle->event_watcher.fd = -1;
-  }
-
-  uv__free(handle->path);
-  handle->path = NULL;
-
-  return r;
-}
-
-
-void uv__fs_event_close(uv_fs_event_t* handle) {
-  uv_fs_event_stop(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/linux-core.cpp b/wpiutil/src/main/native/libuv/src/unix/linux-core.cpp
deleted file mode 100644
index 8a26782..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/linux-core.cpp
+++ /dev/null
@@ -1,1062 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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.
- */
-
-/* We lean on the fact that POLL{IN,OUT,ERR,HUP} correspond with their
- * EPOLL* counterparts.  We use the POLL* variants in this file because that
- * is what libuv uses elsewhere.
- */
-
-#include "uv.h"
-#include "internal.h"
-
-#include <inttypes.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <net/if.h>
-#include <sys/epoll.h>
-#include <sys/param.h>
-#include <sys/prctl.h>
-#include <sys/sysinfo.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <time.h>
-
-#define HAVE_IFADDRS_H 1
-
-#ifdef __UCLIBC__
-# if __UCLIBC_MAJOR__ < 0 && __UCLIBC_MINOR__ < 9 && __UCLIBC_SUBLEVEL__ < 32
-#  undef HAVE_IFADDRS_H
-# endif
-#endif
-
-#ifdef HAVE_IFADDRS_H
-# if defined(__ANDROID__)
-#  include "uv/android-ifaddrs.h"
-# else
-#  include <ifaddrs.h>
-# endif
-# include <sys/socket.h>
-# include <net/ethernet.h>
-# include <netpacket/packet.h>
-#endif /* HAVE_IFADDRS_H */
-
-/* Available from 2.6.32 onwards. */
-#ifndef CLOCK_MONOTONIC_COARSE
-# define CLOCK_MONOTONIC_COARSE 6
-#endif
-
-#ifdef __FRC_ROBORIO__
-#include "wpi/timestamp.h"
-#endif
-
-/* This is rather annoying: CLOCK_BOOTTIME lives in <linux/time.h> but we can't
- * include that file because it conflicts with <time.h>. We'll just have to
- * define it ourselves.
- */
-#ifndef CLOCK_BOOTTIME
-# define CLOCK_BOOTTIME 7
-#endif
-
-static int read_models(unsigned int numcpus, uv_cpu_info_t* ci);
-static int read_times(FILE* statfile_fp,
-                      unsigned int numcpus,
-                      uv_cpu_info_t* ci);
-static void read_speeds(unsigned int numcpus, uv_cpu_info_t* ci);
-static uint64_t read_cpufreq(unsigned int cpunum);
-
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  int fd;
-
-  /* It was reported that EPOLL_CLOEXEC is not defined on Android API < 21,
-   * a.k.a. Lollipop. Since EPOLL_CLOEXEC is an alias for O_CLOEXEC on all
-   * architectures, we just use that instead.
-   */
-  fd = epoll_create1(O_CLOEXEC);
-
-  /* epoll_create1() can fail either because it's not implemented (old kernel)
-   * or because it doesn't understand the O_CLOEXEC flag.
-   */
-  if (fd == -1 && (errno == ENOSYS || errno == EINVAL)) {
-    fd = epoll_create(256);
-
-    if (fd != -1)
-      uv__cloexec(fd, 1);
-  }
-
-  loop->backend_fd = fd;
-  loop->inotify_fd = -1;
-  loop->inotify_watchers = NULL;
-
-  if (fd == -1)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-int uv__io_fork(uv_loop_t* loop) {
-  int err;
-  void* old_watchers;
-
-  old_watchers = loop->inotify_watchers;
-
-  uv__close(loop->backend_fd);
-  loop->backend_fd = -1;
-  uv__platform_loop_delete(loop);
-
-  err = uv__platform_loop_init(loop);
-  if (err)
-    return err;
-
-  return uv__inotify_fork(loop, old_watchers);
-}
-
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-  if (loop->inotify_fd == -1) return;
-  uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN);
-  uv__close(loop->inotify_fd);
-  loop->inotify_fd = -1;
-}
-
-
-void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) {
-  struct epoll_event* events;
-  struct epoll_event dummy;
-  uintptr_t i;
-  uintptr_t nfds;
-
-  assert(loop->watchers != NULL);
-  assert(fd >= 0);
-
-  events = (struct epoll_event*) loop->watchers[loop->nwatchers];
-  nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1];
-  if (events != NULL)
-    /* Invalidate events with same file descriptor */
-    for (i = 0; i < nfds; i++)
-      if (events[i].data.fd == fd)
-        events[i].data.fd = -1;
-
-  /* Remove the file descriptor from the epoll.
-   * This avoids a problem where the same file description remains open
-   * in another process, causing repeated junk epoll events.
-   *
-   * We pass in a dummy epoll_event, to work around a bug in old kernels.
-   */
-  if (loop->backend_fd >= 0) {
-    /* Work around a bug in kernels 3.10 to 3.19 where passing a struct that
-     * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings.
-     */
-    memset(&dummy, 0, sizeof(dummy));
-    epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &dummy);
-  }
-}
-
-
-int uv__io_check_fd(uv_loop_t* loop, int fd) {
-  struct epoll_event e;
-  int rc;
-
-  memset(&e, 0, sizeof(e));
-  e.events = POLLIN;
-  e.data.fd = -1;
-
-  rc = 0;
-  if (epoll_ctl(loop->backend_fd, EPOLL_CTL_ADD, fd, &e))
-    if (errno != EEXIST)
-      rc = UV__ERR(errno);
-
-  if (rc == 0)
-    if (epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &e))
-      abort();
-
-  return rc;
-}
-
-
-void uv__io_poll(uv_loop_t* loop, int timeout) {
-  /* A bug in kernels < 2.6.37 makes timeouts larger than ~30 minutes
-   * effectively infinite on 32 bits architectures.  To avoid blocking
-   * indefinitely, we cap the timeout and poll again if necessary.
-   *
-   * Note that "30 minutes" is a simplification because it depends on
-   * the value of CONFIG_HZ.  The magic constant assumes CONFIG_HZ=1200,
-   * that being the largest value I have seen in the wild (and only once.)
-   */
-  static const int max_safe_timeout = 1789569;
-  struct epoll_event events[1024];
-  struct epoll_event* pe;
-  struct epoll_event e;
-  int real_timeout;
-  QUEUE* q;
-  uv__io_t* w;
-  sigset_t sigset;
-  sigset_t* psigset;
-  uint64_t base;
-  int have_signals;
-  int nevents;
-  int count;
-  int nfds;
-  int fd;
-  int op;
-  int i;
-
-  if (loop->nfds == 0) {
-    assert(QUEUE_EMPTY(&loop->watcher_queue));
-    return;
-  }
-
-  memset(&e, 0, sizeof(e));
-
-  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
-    q = QUEUE_HEAD(&loop->watcher_queue);
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);
-
-    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
-    assert(w->pevents != 0);
-    assert(w->fd >= 0);
-    assert(w->fd < (int) loop->nwatchers);
-
-    e.events = w->pevents;
-    e.data.fd = w->fd;
-
-    if (w->events == 0)
-      op = EPOLL_CTL_ADD;
-    else
-      op = EPOLL_CTL_MOD;
-
-    /* XXX Future optimization: do EPOLL_CTL_MOD lazily if we stop watching
-     * events, skip the syscall and squelch the events after epoll_wait().
-     */
-    if (epoll_ctl(loop->backend_fd, op, w->fd, &e)) {
-      if (errno != EEXIST)
-        abort();
-
-      assert(op == EPOLL_CTL_ADD);
-
-      /* We've reactivated a file descriptor that's been watched before. */
-      if (epoll_ctl(loop->backend_fd, EPOLL_CTL_MOD, w->fd, &e))
-        abort();
-    }
-
-    w->events = w->pevents;
-  }
-
-  psigset = NULL;
-  if (loop->flags & UV_LOOP_BLOCK_SIGPROF) {
-    sigemptyset(&sigset);
-    sigaddset(&sigset, SIGPROF);
-    psigset = &sigset;
-  }
-
-  assert(timeout >= -1);
-  base = loop->time;
-  count = 48; /* Benchmarks suggest this gives the best throughput. */
-  real_timeout = timeout;
-
-  for (;;) {
-    /* See the comment for max_safe_timeout for an explanation of why
-     * this is necessary.  Executive summary: kernel bug workaround.
-     */
-    if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout)
-      timeout = max_safe_timeout;
-
-    nfds = epoll_pwait(loop->backend_fd,
-                       events,
-                       ARRAY_SIZE(events),
-                       timeout,
-                       psigset);
-
-    /* Update loop->time unconditionally. It's tempting to skip the update when
-     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
-     * operating system didn't reschedule our process while in the syscall.
-     */
-    SAVE_ERRNO(uv__update_time(loop));
-
-    if (nfds == 0) {
-      assert(timeout != -1);
-
-      if (timeout == 0)
-        return;
-
-      /* We may have been inside the system call for longer than |timeout|
-       * milliseconds so we need to update the timestamp to avoid drift.
-       */
-      goto update_timeout;
-    }
-
-    if (nfds == -1) {
-      if (errno != EINTR)
-        abort();
-
-      if (timeout == -1)
-        continue;
-
-      if (timeout == 0)
-        return;
-
-      /* Interrupted by a signal. Update timeout and poll again. */
-      goto update_timeout;
-    }
-
-    have_signals = 0;
-    nevents = 0;
-
-    assert(loop->watchers != NULL);
-    loop->watchers[loop->nwatchers] = events;
-    loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds;
-    for (i = 0; i < nfds; i++) {
-      pe = events + i;
-      fd = pe->data.fd;
-
-      /* Skip invalidated events, see uv__platform_invalidate_fd */
-      if (fd == -1)
-        continue;
-
-      assert(fd >= 0);
-      assert((unsigned) fd < loop->nwatchers);
-
-      w = (uv__io_t*)loop->watchers[fd];
-
-      if (w == NULL) {
-        /* File descriptor that we've stopped watching, disarm it.
-         *
-         * Ignore all errors because we may be racing with another thread
-         * when the file descriptor is closed.
-         */
-        epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, pe);
-        continue;
-      }
-
-      /* Give users only events they're interested in. Prevents spurious
-       * callbacks when previous callback invocation in this loop has stopped
-       * the current watcher. Also, filters out events that users has not
-       * requested us to watch.
-       */
-      pe->events &= w->pevents | POLLERR | POLLHUP;
-
-      /* Work around an epoll quirk where it sometimes reports just the
-       * EPOLLERR or EPOLLHUP event.  In order to force the event loop to
-       * move forward, we merge in the read/write events that the watcher
-       * is interested in; uv__read() and uv__write() will then deal with
-       * the error or hangup in the usual fashion.
-       *
-       * Note to self: happens when epoll reports EPOLLIN|EPOLLHUP, the user
-       * reads the available data, calls uv_read_stop(), then sometime later
-       * calls uv_read_start() again.  By then, libuv has forgotten about the
-       * hangup and the kernel won't report EPOLLIN again because there's
-       * nothing left to read.  If anything, libuv is to blame here.  The
-       * current hack is just a quick bandaid; to properly fix it, libuv
-       * needs to remember the error/hangup event.  We should get that for
-       * free when we switch over to edge-triggered I/O.
-       */
-      if (pe->events == POLLERR || pe->events == POLLHUP)
-        pe->events |=
-          w->pevents & (POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
-
-      if (pe->events != 0) {
-        /* Run signal watchers last.  This also affects child process watchers
-         * because those are implemented in terms of signal watchers.
-         */
-        if (w == &loop->signal_io_watcher)
-          have_signals = 1;
-        else
-          w->cb(loop, w, pe->events);
-
-        nevents++;
-      }
-    }
-
-    if (have_signals != 0)
-      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
-
-    loop->watchers[loop->nwatchers] = NULL;
-    loop->watchers[loop->nwatchers + 1] = NULL;
-
-    if (have_signals != 0)
-      return;  /* Event loop should cycle now so don't poll again. */
-
-    if (nevents != 0) {
-      if (nfds == ARRAY_SIZE(events) && --count != 0) {
-        /* Poll for more events but don't block this time. */
-        timeout = 0;
-        continue;
-      }
-      return;
-    }
-
-    if (timeout == 0)
-      return;
-
-    if (timeout == -1)
-      continue;
-
-update_timeout:
-    assert(timeout > 0);
-
-    real_timeout -= (loop->time - base);
-    if (real_timeout <= 0)
-      return;
-
-    timeout = real_timeout;
-  }
-}
-
-
-uint64_t uv__hrtime(uv_clocktype_t type) {
-#ifdef __FRC_ROBORIO__
-  return wpi::Now() * 1000u;
-#else
-  static clock_t fast_clock_id = -1;
-  struct timespec t;
-  clock_t clock_id;
-
-  /* Prefer CLOCK_MONOTONIC_COARSE if available but only when it has
-   * millisecond granularity or better.  CLOCK_MONOTONIC_COARSE is
-   * serviced entirely from the vDSO, whereas CLOCK_MONOTONIC may
-   * decide to make a costly system call.
-   */
-  /* TODO(bnoordhuis) Use CLOCK_MONOTONIC_COARSE for UV_CLOCK_PRECISE
-   * when it has microsecond granularity or better (unlikely).
-   */
-  if (type == UV_CLOCK_FAST && fast_clock_id == -1) {
-    if (clock_getres(CLOCK_MONOTONIC_COARSE, &t) == 0 &&
-        t.tv_nsec <= 1 * 1000 * 1000) {
-      fast_clock_id = CLOCK_MONOTONIC_COARSE;
-    } else {
-      fast_clock_id = CLOCK_MONOTONIC;
-    }
-  }
-
-  clock_id = CLOCK_MONOTONIC;
-  if (type == UV_CLOCK_FAST)
-    clock_id = fast_clock_id;
-
-  if (clock_gettime(clock_id, &t))
-    return 0;  /* Not really possible. */
-
-  return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec;
-#endif
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  char buf[1024];
-  const char* s;
-  ssize_t n;
-  long val;
-  int fd;
-  int i;
-
-  do
-    fd = open("/proc/self/stat", O_RDONLY);
-  while (fd == -1 && errno == EINTR);
-
-  if (fd == -1)
-    return UV__ERR(errno);
-
-  do
-    n = read(fd, buf, sizeof(buf) - 1);
-  while (n == -1 && errno == EINTR);
-
-  uv__close(fd);
-  if (n == -1)
-    return UV__ERR(errno);
-  buf[n] = '\0';
-
-  s = strchr(buf, ' ');
-  if (s == NULL)
-    goto err;
-
-  s += 1;
-  if (*s != '(')
-    goto err;
-
-  s = strchr(s, ')');
-  if (s == NULL)
-    goto err;
-
-  for (i = 1; i <= 22; i++) {
-    s = strchr(s + 1, ' ');
-    if (s == NULL)
-      goto err;
-  }
-
-  errno = 0;
-  val = strtol(s, NULL, 10);
-  if (errno != 0)
-    goto err;
-  if (val < 0)
-    goto err;
-
-  *rss = val * getpagesize();
-  return 0;
-
-err:
-  return UV_EINVAL;
-}
-
-
-int uv_uptime(double* uptime) {
-  static volatile int no_clock_boottime;
-  struct timespec now;
-  int r;
-
-  /* Try CLOCK_BOOTTIME first, fall back to CLOCK_MONOTONIC if not available
-   * (pre-2.6.39 kernels). CLOCK_MONOTONIC doesn't increase when the system
-   * is suspended.
-   */
-  if (no_clock_boottime) {
-    retry: r = clock_gettime(CLOCK_MONOTONIC, &now);
-  }
-  else if ((r = clock_gettime(CLOCK_BOOTTIME, &now)) && errno == EINVAL) {
-    no_clock_boottime = 1;
-    goto retry;
-  }
-
-  if (r)
-    return UV__ERR(errno);
-
-  *uptime = now.tv_sec;
-  return 0;
-}
-
-
-static int uv__cpu_num(FILE* statfile_fp, unsigned int* numcpus) {
-  unsigned int num;
-  char buf[1024];
-
-  if (!fgets(buf, sizeof(buf), statfile_fp))
-    return UV_EIO;
-
-  num = 0;
-  while (fgets(buf, sizeof(buf), statfile_fp)) {
-    if (strncmp(buf, "cpu", 3))
-      break;
-    num++;
-  }
-
-  if (num == 0)
-    return UV_EIO;
-
-  *numcpus = num;
-  return 0;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int numcpus;
-  uv_cpu_info_t* ci;
-  int err;
-  FILE* statfile_fp;
-
-  *cpu_infos = NULL;
-  *count = 0;
-
-  statfile_fp = uv__open_file("/proc/stat");
-  if (statfile_fp == NULL)
-    return UV__ERR(errno);
-
-  err = uv__cpu_num(statfile_fp, &numcpus);
-  if (err < 0)
-    goto out;
-
-  err = UV_ENOMEM;
-  ci = (uv_cpu_info_t*)uv__calloc(numcpus, sizeof(*ci));
-  if (ci == NULL)
-    goto out;
-
-  err = read_models(numcpus, ci);
-  if (err == 0)
-    err = read_times(statfile_fp, numcpus, ci);
-
-  if (err) {
-    uv_free_cpu_info(ci, numcpus);
-    goto out;
-  }
-
-  /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo.
-   * We don't check for errors here. Worst case, the field is left zero.
-   */
-  if (ci[0].speed == 0)
-    read_speeds(numcpus, ci);
-
-  *cpu_infos = ci;
-  *count = numcpus;
-  err = 0;
-
-out:
-
-  if (fclose(statfile_fp))
-    if (errno != EINTR && errno != EINPROGRESS)
-      abort();
-
-  return err;
-}
-
-
-static void read_speeds(unsigned int numcpus, uv_cpu_info_t* ci) {
-  unsigned int num;
-
-  for (num = 0; num < numcpus; num++)
-    ci[num].speed = read_cpufreq(num) / 1000;
-}
-
-
-/* Also reads the CPU frequency on x86. The other architectures only have
- * a BogoMIPS field, which may not be very accurate.
- *
- * Note: Simply returns on error, uv_cpu_info() takes care of the cleanup.
- */
-static int read_models(unsigned int numcpus, uv_cpu_info_t* ci) {
-  static const char model_marker[] = "model name\t: ";
-  static const char speed_marker[] = "cpu MHz\t\t: ";
-  const char* inferred_model;
-  unsigned int model_idx;
-  unsigned int speed_idx;
-  char buf[1024];
-  char* model;
-  FILE* fp;
-
-  /* Most are unused on non-ARM, non-MIPS and non-x86 architectures. */
-  (void) &model_marker;
-  (void) &speed_marker;
-  (void) &speed_idx;
-  (void) &model;
-  (void) &buf;
-  (void) &fp;
-
-  model_idx = 0;
-  speed_idx = 0;
-
-#if defined(__arm__) || \
-    defined(__i386__) || \
-    defined(__mips__) || \
-    defined(__x86_64__)
-  fp = uv__open_file("/proc/cpuinfo");
-  if (fp == NULL)
-    return UV__ERR(errno);
-
-  while (fgets(buf, sizeof(buf), fp)) {
-    if (model_idx < numcpus) {
-      if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) {
-        model = buf + sizeof(model_marker) - 1;
-        model = uv__strndup(model, strlen(model) - 1);  /* Strip newline. */
-        if (model == NULL) {
-          fclose(fp);
-          return UV_ENOMEM;
-        }
-        ci[model_idx++].model = model;
-        continue;
-      }
-    }
-#if defined(__arm__) || defined(__mips__)
-    if (model_idx < numcpus) {
-#if defined(__arm__)
-      /* Fallback for pre-3.8 kernels. */
-      static const char model_marker[] = "Processor\t: ";
-#else	/* defined(__mips__) */
-      static const char model_marker[] = "cpu model\t\t: ";
-#endif
-      if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) {
-        model = buf + sizeof(model_marker) - 1;
-        model = uv__strndup(model, strlen(model) - 1);  /* Strip newline. */
-        if (model == NULL) {
-          fclose(fp);
-          return UV_ENOMEM;
-        }
-        ci[model_idx++].model = model;
-        continue;
-      }
-    }
-#else  /* !__arm__ && !__mips__ */
-    if (speed_idx < numcpus) {
-      if (strncmp(buf, speed_marker, sizeof(speed_marker) - 1) == 0) {
-        ci[speed_idx++].speed = atoi(buf + sizeof(speed_marker) - 1);
-        continue;
-      }
-    }
-#endif  /* __arm__ || __mips__ */
-  }
-
-  fclose(fp);
-#endif  /* __arm__ || __i386__ || __mips__ || __x86_64__ */
-
-  /* Now we want to make sure that all the models contain *something* because
-   * it's not safe to leave them as null. Copy the last entry unless there
-   * isn't one, in that case we simply put "unknown" into everything.
-   */
-  inferred_model = "unknown";
-  if (model_idx > 0)
-    inferred_model = ci[model_idx - 1].model;
-
-  while (model_idx < numcpus) {
-    model = uv__strndup(inferred_model, strlen(inferred_model));
-    if (model == NULL)
-      return UV_ENOMEM;
-    ci[model_idx++].model = model;
-  }
-
-  return 0;
-}
-
-
-static int read_times(FILE* statfile_fp,
-                      unsigned int numcpus,
-                      uv_cpu_info_t* ci) {
-  struct uv_cpu_times_s ts;
-  uint64_t clock_ticks;
-  uint64_t user;
-  uint64_t nice;
-  uint64_t sys;
-  uint64_t idle;
-  uint64_t dummy;
-  uint64_t irq;
-  uint64_t num;
-  uint64_t len;
-  char buf[1024];
-
-  clock_ticks = sysconf(_SC_CLK_TCK);
-  assert(clock_ticks != (uint64_t) -1);
-  assert(clock_ticks != 0);
-
-  rewind(statfile_fp);
-
-  if (!fgets(buf, sizeof(buf), statfile_fp))
-    abort();
-
-  num = 0;
-
-  while (fgets(buf, sizeof(buf), statfile_fp)) {
-    if (num >= numcpus)
-      break;
-
-    if (strncmp(buf, "cpu", 3))
-      break;
-
-    /* skip "cpu<num> " marker */
-    {
-      unsigned int n;
-      int r = sscanf(buf, "cpu%u ", &n);
-      assert(r == 1);
-      (void) r;  /* silence build warning */
-      for (len = sizeof("cpu0"); n /= 10; len++);
-    }
-
-    /* Line contains user, nice, system, idle, iowait, irq, softirq, steal,
-     * guest, guest_nice but we're only interested in the first four + irq.
-     *
-     * Don't use %*s to skip fields or %ll to read straight into the uint64_t
-     * fields, they're not allowed in C89 mode.
-     */
-    if (6 != sscanf(buf + len,
-                    "%" PRIu64 " %" PRIu64 " %" PRIu64
-                    "%" PRIu64 " %" PRIu64 " %" PRIu64,
-                    &user,
-                    &nice,
-                    &sys,
-                    &idle,
-                    &dummy,
-                    &irq))
-      abort();
-
-    ts.user = clock_ticks * user;
-    ts.nice = clock_ticks * nice;
-    ts.sys  = clock_ticks * sys;
-    ts.idle = clock_ticks * idle;
-    ts.irq  = clock_ticks * irq;
-    ci[num++].cpu_times = ts;
-  }
-  assert(num == numcpus);
-
-  return 0;
-}
-
-
-static uint64_t read_cpufreq(unsigned int cpunum) {
-  uint64_t val;
-  char buf[1024];
-  FILE* fp;
-
-  snprintf(buf,
-           sizeof(buf),
-           "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_cur_freq",
-           cpunum);
-
-  fp = uv__open_file(buf);
-  if (fp == NULL)
-    return 0;
-
-  if (fscanf(fp, "%" PRIu64, &val) != 1)
-    val = 0;
-
-  fclose(fp);
-
-  return val;
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
-
-static int uv__ifaddr_exclude(struct ifaddrs *ent, int exclude_type) {
-  if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)))
-    return 1;
-  if (ent->ifa_addr == NULL)
-    return 1;
-  /*
-   * On Linux getifaddrs returns information related to the raw underlying
-   * devices. We're not interested in this information yet.
-   */
-  if (ent->ifa_addr->sa_family == PF_PACKET)
-    return exclude_type;
-  return !exclude_type;
-}
-
-int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
-#ifndef HAVE_IFADDRS_H
-  *count = 0;
-  *addresses = NULL;
-  return UV_ENOSYS;
-#else
-  struct ifaddrs *addrs, *ent;
-  uv_interface_address_t* address;
-  int i;
-  struct sockaddr_ll *sll;
-
-  *count = 0;
-  *addresses = NULL;
-
-  if (getifaddrs(&addrs))
-    return UV__ERR(errno);
-
-  /* Count the number of interfaces */
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
-      continue;
-
-    (*count)++;
-  }
-
-  if (*count == 0) {
-    freeifaddrs(addrs);
-    return 0;
-  }
-
-  /* Make sure the memory is initiallized to zero using calloc() */
-  *addresses = (uv_interface_address_t*)uv__calloc(*count, sizeof(**addresses));
-  if (!(*addresses)) {
-    freeifaddrs(addrs);
-    return UV_ENOMEM;
-  }
-
-  address = *addresses;
-
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
-      continue;
-
-    address->name = uv__strdup(ent->ifa_name);
-
-    if (ent->ifa_addr->sa_family == AF_INET6) {
-      address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr);
-    } else {
-      address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr);
-    }
-
-    if (ent->ifa_netmask->sa_family == AF_INET6) {
-      address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask);
-    } else {
-      address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask);
-    }
-
-    address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK);
-
-    address++;
-  }
-
-  /* Fill in physical addresses for each interface */
-  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
-    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFPHYS))
-      continue;
-
-    address = *addresses;
-
-    for (i = 0; i < (*count); i++) {
-      size_t namelen = strlen(ent->ifa_name);
-      /* Alias interface share the same physical address */
-      if (strncmp(address->name, ent->ifa_name, namelen) == 0 &&
-          (address->name[namelen] == 0 || address->name[namelen] == ':')) {
-        sll = (struct sockaddr_ll*)ent->ifa_addr;
-        memcpy(address->phys_addr, sll->sll_addr, sizeof(address->phys_addr));
-      }
-      address++;
-    }
-  }
-
-  freeifaddrs(addrs);
-
-  return 0;
-#endif
-}
-
-
-void uv_free_interface_addresses(uv_interface_address_t* addresses,
-  int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(addresses[i].name);
-  }
-
-  uv__free(addresses);
-}
-
-
-void uv__set_process_title(const char* title) {
-#if defined(PR_SET_NAME)
-  prctl(PR_SET_NAME, title);  /* Only copies first 16 characters. */
-#endif
-}
-
-
-static uint64_t uv__read_proc_meminfo(const char* what) {
-  uint64_t rc;
-  ssize_t n;
-  char* p;
-  int fd;
-  char buf[4096];  /* Large enough to hold all of /proc/meminfo. */
-
-  rc = 0;
-  fd = uv__open_cloexec("/proc/meminfo", O_RDONLY);
-
-  if (fd == -1)
-    return 0;
-
-  n = read(fd, buf, sizeof(buf) - 1);
-
-  if (n <= 0)
-    goto out;
-
-  buf[n] = '\0';
-  p = strstr(buf, what);
-
-  if (p == NULL)
-    goto out;
-
-  p += strlen(what);
-
-  if (1 != sscanf(p, "%" PRIu64 " kB", &rc))
-    goto out;
-
-  rc *= 1024;
-
-out:
-
-  if (uv__close_nocheckstdio(fd))
-    abort();
-
-  return rc;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  struct sysinfo info;
-  uint64_t rc;
-
-  rc = uv__read_proc_meminfo("MemFree:");
-
-  if (rc != 0)
-    return rc;
-
-  if (0 == sysinfo(&info))
-    return (uint64_t) info.freeram * info.mem_unit;
-
-  return 0;
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  struct sysinfo info;
-  uint64_t rc;
-
-  rc = uv__read_proc_meminfo("MemTotal:");
-
-  if (rc != 0)
-    return rc;
-
-  if (0 == sysinfo(&info))
-    return (uint64_t) info.totalram * info.mem_unit;
-
-  return 0;
-}
-
-
-static uint64_t uv__read_cgroups_uint64(const char* cgroup, const char* param) {
-  char filename[256];
-  uint64_t rc;
-  int fd;
-  ssize_t n;
-  char buf[32];  /* Large enough to hold an encoded uint64_t. */
-
-  snprintf(filename, 256, "/sys/fs/cgroup/%s/%s", cgroup, param);
-
-  rc = 0;
-  fd = uv__open_cloexec(filename, O_RDONLY);
-
-  if (fd < 0)
-    return 0;
-
-  n = read(fd, buf, sizeof(buf) - 1);
-
-  if (n > 0) {
-    buf[n] = '\0';
-    sscanf(buf, "%" PRIu64, &rc);
-  }
-
-  if (uv__close_nocheckstdio(fd))
-    abort();
-
-  return rc;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  /*
-   * This might return 0 if there was a problem getting the memory limit from
-   * cgroups. This is OK because a return value of 0 signifies that the memory
-   * limit is unknown.
-   */
-  return uv__read_cgroups_uint64("memory", "memory.limit_in_bytes");
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/linux-inotify.cpp b/wpiutil/src/main/native/libuv/src/unix/linux-inotify.cpp
deleted file mode 100644
index ed484cc..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/linux-inotify.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "uv/tree.h"
-#include "internal.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <unistd.h>
-
-struct watcher_list {
-  RB_ENTRY(watcher_list) entry;
-  QUEUE watchers;
-  int iterating;
-  char* path;
-  int wd;
-};
-
-struct watcher_root {
-  struct watcher_list* rbh_root;
-};
-#define CAST(p) ((struct watcher_root*)(p))
-
-
-static int compare_watchers(const struct watcher_list* a,
-                            const struct watcher_list* b) {
-  if (a->wd < b->wd) return -1;
-  if (a->wd > b->wd) return 1;
-  return 0;
-}
-
-
-RB_GENERATE_STATIC(watcher_root, watcher_list, entry, compare_watchers)
-
-
-static void uv__inotify_read(uv_loop_t* loop,
-                             uv__io_t* w,
-                             unsigned int revents);
-
-static void maybe_free_watcher_list(struct watcher_list* w,
-                                    uv_loop_t* loop);
-
-static int new_inotify_fd(void) {
-  int err;
-  int fd;
-
-  fd = uv__inotify_init1(UV__IN_NONBLOCK | UV__IN_CLOEXEC);
-  if (fd != -1)
-    return fd;
-
-  if (errno != ENOSYS)
-    return UV__ERR(errno);
-
-  fd = uv__inotify_init();
-  if (fd == -1)
-    return UV__ERR(errno);
-
-  err = uv__cloexec(fd, 1);
-  if (err == 0)
-    err = uv__nonblock(fd, 1);
-
-  if (err) {
-    uv__close(fd);
-    return err;
-  }
-
-  return fd;
-}
-
-
-static int init_inotify(uv_loop_t* loop) {
-  int err;
-
-  if (loop->inotify_fd != -1)
-    return 0;
-
-  err = new_inotify_fd();
-  if (err < 0)
-    return err;
-
-  loop->inotify_fd = err;
-  uv__io_init(&loop->inotify_read_watcher, uv__inotify_read, loop->inotify_fd);
-  uv__io_start(loop, &loop->inotify_read_watcher, POLLIN);
-
-  return 0;
-}
-
-
-int uv__inotify_fork(uv_loop_t* loop, void* old_watchers) {
-  /* Open the inotify_fd, and re-arm all the inotify watchers. */
-  int err;
-  struct watcher_list* tmp_watcher_list_iter;
-  struct watcher_list* watcher_list;
-  struct watcher_list tmp_watcher_list;
-  QUEUE queue;
-  QUEUE* q;
-  uv_fs_event_t* handle;
-  char* tmp_path;
-
-  if (old_watchers != NULL) {
-    /* We must restore the old watcher list to be able to close items
-     * out of it.
-     */
-    loop->inotify_watchers = old_watchers;
-
-    QUEUE_INIT(&tmp_watcher_list.watchers);
-    /* Note that the queue we use is shared with the start and stop()
-     * functions, making QUEUE_FOREACH unsafe to use. So we use the
-     * QUEUE_MOVE trick to safely iterate. Also don't free the watcher
-     * list until we're done iterating. c.f. uv__inotify_read.
-     */
-    RB_FOREACH_SAFE(watcher_list, watcher_root,
-                    CAST(&old_watchers), tmp_watcher_list_iter) {
-      watcher_list->iterating = 1;
-      QUEUE_MOVE(&watcher_list->watchers, &queue);
-      while (!QUEUE_EMPTY(&queue)) {
-        q = QUEUE_HEAD(&queue);
-        handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
-        /* It's critical to keep a copy of path here, because it
-         * will be set to NULL by stop() and then deallocated by
-         * maybe_free_watcher_list
-         */
-        tmp_path = uv__strdup(handle->path);
-        assert(tmp_path != NULL);
-        QUEUE_REMOVE(q);
-        QUEUE_INSERT_TAIL(&watcher_list->watchers, q);
-        uv_fs_event_stop(handle);
-
-        QUEUE_INSERT_TAIL(&tmp_watcher_list.watchers, &handle->watchers);
-        handle->path = tmp_path;
-      }
-      watcher_list->iterating = 0;
-      maybe_free_watcher_list(watcher_list, loop);
-    }
-
-    QUEUE_MOVE(&tmp_watcher_list.watchers, &queue);
-    while (!QUEUE_EMPTY(&queue)) {
-        q = QUEUE_HEAD(&queue);
-        QUEUE_REMOVE(q);
-        handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
-        tmp_path = handle->path;
-        handle->path = NULL;
-        err = uv_fs_event_start(handle, handle->cb, tmp_path, 0);
-        uv__free(tmp_path);
-        if (err)
-          return err;
-    }
-  }
-
-  return 0;
-}
-
-
-static struct watcher_list* find_watcher(uv_loop_t* loop, int wd) {
-  struct watcher_list w;
-  w.wd = wd;
-  return RB_FIND(watcher_root, CAST(&loop->inotify_watchers), &w);
-}
-
-static void maybe_free_watcher_list(struct watcher_list* w, uv_loop_t* loop) {
-  /* if the watcher_list->watchers is being iterated over, we can't free it. */
-  if ((!w->iterating) && QUEUE_EMPTY(&w->watchers)) {
-    /* No watchers left for this path. Clean up. */
-    RB_REMOVE(watcher_root, CAST(&loop->inotify_watchers), w);
-    uv__inotify_rm_watch(loop->inotify_fd, w->wd);
-    uv__free(w);
-  }
-}
-
-static void uv__inotify_read(uv_loop_t* loop,
-                             uv__io_t* dummy,
-                             unsigned int events) {
-  const struct uv__inotify_event* e;
-  struct watcher_list* w;
-  uv_fs_event_t* h;
-  QUEUE queue;
-  QUEUE* q;
-  const char* path;
-  ssize_t size;
-  const char *p;
-  /* needs to be large enough for sizeof(inotify_event) + strlen(path) */
-  char buf[4096];
-
-  while (1) {
-    do
-      size = read(loop->inotify_fd, buf, sizeof(buf));
-    while (size == -1 && errno == EINTR);
-
-    if (size == -1) {
-      assert(errno == EAGAIN || errno == EWOULDBLOCK);
-      break;
-    }
-
-    assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */
-
-    /* Now we have one or more inotify_event structs. */
-    for (p = buf; p < buf + size; p += sizeof(*e) + e->len) {
-      e = (const struct uv__inotify_event*)p;
-
-      events = 0;
-      if (e->mask & (UV__IN_ATTRIB|UV__IN_MODIFY))
-        events |= UV_CHANGE;
-      if (e->mask & ~(UV__IN_ATTRIB|UV__IN_MODIFY))
-        events |= UV_RENAME;
-
-      w = find_watcher(loop, e->wd);
-      if (w == NULL)
-        continue; /* Stale event, no watchers left. */
-
-      /* inotify does not return the filename when monitoring a single file
-       * for modifications. Repurpose the filename for API compatibility.
-       * I'm not convinced this is a good thing, maybe it should go.
-       */
-      path = e->len ? (const char*) (e + 1) : uv__basename_r(w->path);
-
-      /* We're about to iterate over the queue and call user's callbacks.
-       * What can go wrong?
-       * A callback could call uv_fs_event_stop()
-       * and the queue can change under our feet.
-       * So, we use QUEUE_MOVE() trick to safely iterate over the queue.
-       * And we don't free the watcher_list until we're done iterating.
-       *
-       * First,
-       * tell uv_fs_event_stop() (that could be called from a user's callback)
-       * not to free watcher_list.
-       */
-      w->iterating = 1;
-      QUEUE_MOVE(&w->watchers, &queue);
-      while (!QUEUE_EMPTY(&queue)) {
-        q = QUEUE_HEAD(&queue);
-        h = QUEUE_DATA(q, uv_fs_event_t, watchers);
-
-        QUEUE_REMOVE(q);
-        QUEUE_INSERT_TAIL(&w->watchers, q);
-
-        h->cb(h, path, events, 0);
-      }
-      /* done iterating, time to (maybe) free empty watcher_list */
-      w->iterating = 0;
-      maybe_free_watcher_list(w, loop);
-    }
-  }
-}
-
-
-int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
-  return 0;
-}
-
-
-int uv_fs_event_start(uv_fs_event_t* handle,
-                      uv_fs_event_cb cb,
-                      const char* path,
-                      unsigned int flags) {
-  struct watcher_list* w;
-  size_t len;
-  int events;
-  int err;
-  int wd;
-
-  if (uv__is_active(handle))
-    return UV_EINVAL;
-
-  err = init_inotify(handle->loop);
-  if (err)
-    return err;
-
-  events = UV__IN_ATTRIB
-         | UV__IN_CREATE
-         | UV__IN_MODIFY
-         | UV__IN_DELETE
-         | UV__IN_DELETE_SELF
-         | UV__IN_MOVE_SELF
-         | UV__IN_MOVED_FROM
-         | UV__IN_MOVED_TO;
-
-  wd = uv__inotify_add_watch(handle->loop->inotify_fd, path, events);
-  if (wd == -1)
-    return UV__ERR(errno);
-
-  w = find_watcher(handle->loop, wd);
-  if (w)
-    goto no_insert;
-
-  len = strlen(path) + 1;
-  w = (watcher_list*)uv__malloc(sizeof(*w) + len);
-  if (w == NULL)
-    return UV_ENOMEM;
-
-  w->wd = wd;
-  w->path = (char*)memcpy(w + 1, path, len);
-  QUEUE_INIT(&w->watchers);
-  w->iterating = 0;
-  RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w);
-
-no_insert:
-  uv__handle_start(handle);
-  QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers);
-  handle->path = w->path;
-  handle->cb = cb;
-  handle->wd = wd;
-
-  return 0;
-}
-
-
-int uv_fs_event_stop(uv_fs_event_t* handle) {
-  struct watcher_list* w;
-
-  if (!uv__is_active(handle))
-    return 0;
-
-  w = find_watcher(handle->loop, handle->wd);
-  assert(w != NULL);
-
-  handle->wd = -1;
-  handle->path = NULL;
-  uv__handle_stop(handle);
-  QUEUE_REMOVE(&handle->watchers);
-
-  maybe_free_watcher_list(w, handle->loop);
-
-  return 0;
-}
-
-
-void uv__fs_event_close(uv_fs_event_t* handle) {
-  uv_fs_event_stop(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.cpp b/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.cpp
deleted file mode 100644
index 5637cf9..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "linux-syscalls.h"
-#include <unistd.h>
-#include <signal.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <errno.h>
-
-#if defined(__has_feature)
-# if __has_feature(memory_sanitizer)
-#  define MSAN_ACTIVE 1
-#  include <sanitizer/msan_interface.h>
-# endif
-#endif
-
-#if defined(__i386__)
-# ifndef __NR_socketcall
-#  define __NR_socketcall 102
-# endif
-#endif
-
-#if defined(__arm__)
-# if defined(__thumb__) || defined(__ARM_EABI__)
-#  define UV_SYSCALL_BASE 0
-# else
-#  define UV_SYSCALL_BASE 0x900000
-# endif
-#endif /* __arm__ */
-
-#ifndef __NR_accept4
-# if defined(__x86_64__)
-#  define __NR_accept4 288
-# elif defined(__i386__)
-   /* Nothing. Handled through socketcall(). */
-# elif defined(__arm__)
-#  define __NR_accept4 (UV_SYSCALL_BASE + 366)
-# endif
-#endif /* __NR_accept4 */
-
-#ifndef __NR_eventfd
-# if defined(__x86_64__)
-#  define __NR_eventfd 284
-# elif defined(__i386__)
-#  define __NR_eventfd 323
-# elif defined(__arm__)
-#  define __NR_eventfd (UV_SYSCALL_BASE + 351)
-# endif
-#endif /* __NR_eventfd */
-
-#ifndef __NR_eventfd2
-# if defined(__x86_64__)
-#  define __NR_eventfd2 290
-# elif defined(__i386__)
-#  define __NR_eventfd2 328
-# elif defined(__arm__)
-#  define __NR_eventfd2 (UV_SYSCALL_BASE + 356)
-# endif
-#endif /* __NR_eventfd2 */
-
-#ifndef __NR_inotify_init
-# if defined(__x86_64__)
-#  define __NR_inotify_init 253
-# elif defined(__i386__)
-#  define __NR_inotify_init 291
-# elif defined(__arm__)
-#  define __NR_inotify_init (UV_SYSCALL_BASE + 316)
-# endif
-#endif /* __NR_inotify_init */
-
-#ifndef __NR_inotify_init1
-# if defined(__x86_64__)
-#  define __NR_inotify_init1 294
-# elif defined(__i386__)
-#  define __NR_inotify_init1 332
-# elif defined(__arm__)
-#  define __NR_inotify_init1 (UV_SYSCALL_BASE + 360)
-# endif
-#endif /* __NR_inotify_init1 */
-
-#ifndef __NR_inotify_add_watch
-# if defined(__x86_64__)
-#  define __NR_inotify_add_watch 254
-# elif defined(__i386__)
-#  define __NR_inotify_add_watch 292
-# elif defined(__arm__)
-#  define __NR_inotify_add_watch (UV_SYSCALL_BASE + 317)
-# endif
-#endif /* __NR_inotify_add_watch */
-
-#ifndef __NR_inotify_rm_watch
-# if defined(__x86_64__)
-#  define __NR_inotify_rm_watch 255
-# elif defined(__i386__)
-#  define __NR_inotify_rm_watch 293
-# elif defined(__arm__)
-#  define __NR_inotify_rm_watch (UV_SYSCALL_BASE + 318)
-# endif
-#endif /* __NR_inotify_rm_watch */
-
-#ifndef __NR_pipe2
-# if defined(__x86_64__)
-#  define __NR_pipe2 293
-# elif defined(__i386__)
-#  define __NR_pipe2 331
-# elif defined(__arm__)
-#  define __NR_pipe2 (UV_SYSCALL_BASE + 359)
-# endif
-#endif /* __NR_pipe2 */
-
-#ifndef __NR_recvmmsg
-# if defined(__x86_64__)
-#  define __NR_recvmmsg 299
-# elif defined(__i386__)
-#  define __NR_recvmmsg 337
-# elif defined(__arm__)
-#  define __NR_recvmmsg (UV_SYSCALL_BASE + 365)
-# endif
-#endif /* __NR_recvmsg */
-
-#ifndef __NR_sendmmsg
-# if defined(__x86_64__)
-#  define __NR_sendmmsg 307
-# elif defined(__i386__)
-#  define __NR_sendmmsg 345
-# elif defined(__arm__)
-#  define __NR_sendmmsg (UV_SYSCALL_BASE + 374)
-# endif
-#endif /* __NR_sendmmsg */
-
-#ifndef __NR_utimensat
-# if defined(__x86_64__)
-#  define __NR_utimensat 280
-# elif defined(__i386__)
-#  define __NR_utimensat 320
-# elif defined(__arm__)
-#  define __NR_utimensat (UV_SYSCALL_BASE + 348)
-# endif
-#endif /* __NR_utimensat */
-
-#ifndef __NR_preadv
-# if defined(__x86_64__)
-#  define __NR_preadv 295
-# elif defined(__i386__)
-#  define __NR_preadv 333
-# elif defined(__arm__)
-#  define __NR_preadv (UV_SYSCALL_BASE + 361)
-# endif
-#endif /* __NR_preadv */
-
-#ifndef __NR_pwritev
-# if defined(__x86_64__)
-#  define __NR_pwritev 296
-# elif defined(__i386__)
-#  define __NR_pwritev 334
-# elif defined(__arm__)
-#  define __NR_pwritev (UV_SYSCALL_BASE + 362)
-# endif
-#endif /* __NR_pwritev */
-
-#ifndef __NR_dup3
-# if defined(__x86_64__)
-#  define __NR_dup3 292
-# elif defined(__i386__)
-#  define __NR_dup3 330
-# elif defined(__arm__)
-#  define __NR_dup3 (UV_SYSCALL_BASE + 358)
-# endif
-#endif /* __NR_pwritev */
-
-#ifndef __NR_statx
-# if defined(__x86_64__)
-#  define __NR_statx 332
-# elif defined(__i386__)
-#  define __NR_statx 383
-# elif defined(__aarch64__)
-#  define __NR_statx 397
-# elif defined(__arm__)
-#  define __NR_statx (UV_SYSCALL_BASE + 397)
-# elif defined(__ppc__)
-#  define __NR_statx 383
-# elif defined(__s390__)
-#  define __NR_statx 379
-# endif
-#endif /* __NR_statx */
-
-int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags) {
-#if defined(__i386__)
-  unsigned long args[4];
-  int r;
-
-  args[0] = (unsigned long) fd;
-  args[1] = (unsigned long) addr;
-  args[2] = (unsigned long) addrlen;
-  args[3] = (unsigned long) flags;
-
-  r = syscall(__NR_socketcall, 18 /* SYS_ACCEPT4 */, args);
-
-  /* socketcall() raises EINVAL when SYS_ACCEPT4 is not supported but so does
-   * a bad flags argument. Try to distinguish between the two cases.
-   */
-  if (r == -1)
-    if (errno == EINVAL)
-      if ((flags & ~(UV__SOCK_CLOEXEC|UV__SOCK_NONBLOCK)) == 0)
-        errno = ENOSYS;
-
-  return r;
-#elif defined(__NR_accept4)
-  return syscall(__NR_accept4, fd, addr, addrlen, flags);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__eventfd(unsigned int count) {
-#if defined(__NR_eventfd)
-  return syscall(__NR_eventfd, count);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__eventfd2(unsigned int count, int flags) {
-#if defined(__NR_eventfd2)
-  return syscall(__NR_eventfd2, count, flags);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__inotify_init(void) {
-#if defined(__NR_inotify_init)
-  return syscall(__NR_inotify_init);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__inotify_init1(int flags) {
-#if defined(__NR_inotify_init1)
-  return syscall(__NR_inotify_init1, flags);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__inotify_add_watch(int fd, const char* path, uint32_t mask) {
-#if defined(__NR_inotify_add_watch)
-  return syscall(__NR_inotify_add_watch, fd, path, mask);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__inotify_rm_watch(int fd, int32_t wd) {
-#if defined(__NR_inotify_rm_watch)
-  return syscall(__NR_inotify_rm_watch, fd, wd);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__pipe2(int pipefd[2], int flags) {
-#if defined(__NR_pipe2)
-  int result;
-  result = syscall(__NR_pipe2, pipefd, flags);
-#if MSAN_ACTIVE
-  if (!result)
-    __msan_unpoison(pipefd, sizeof(int[2]));
-#endif
-  return result;
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__sendmmsg(int fd,
-                 struct uv__mmsghdr* mmsg,
-                 unsigned int vlen,
-                 unsigned int flags) {
-#if defined(__NR_sendmmsg)
-  return syscall(__NR_sendmmsg, fd, mmsg, vlen, flags);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__recvmmsg(int fd,
-                 struct uv__mmsghdr* mmsg,
-                 unsigned int vlen,
-                 unsigned int flags,
-                 struct timespec* timeout) {
-#if defined(__NR_recvmmsg)
-  return syscall(__NR_recvmmsg, fd, mmsg, vlen, flags, timeout);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-ssize_t uv__preadv(int fd, const struct iovec *iov, int iovcnt, int64_t offset) {
-#if defined(__NR_preadv)
-  return syscall(__NR_preadv, fd, iov, iovcnt, (long)offset, (long)(offset >> 32));
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-ssize_t uv__pwritev(int fd, const struct iovec *iov, int iovcnt, int64_t offset) {
-#if defined(__NR_pwritev)
-  return syscall(__NR_pwritev, fd, iov, iovcnt, (long)offset, (long)(offset >> 32));
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__dup3(int oldfd, int newfd, int flags) {
-#if defined(__NR_dup3)
-  return syscall(__NR_dup3, oldfd, newfd, flags);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
-
-
-int uv__statx(int dirfd,
-              const char* path,
-              int flags,
-              unsigned int mask,
-              struct uv__statx* statxbuf) {
-  /* __NR_statx make Android box killed by SIGSYS.
-   * That looks like a seccomp2 sandbox filter rejecting the system call.
-   */
-#if defined(__NR_statx) && !defined(__ANDROID__)
-  return syscall(__NR_statx, dirfd, path, flags, mask, statxbuf);
-#else
-  return errno = ENOSYS, -1;
-#endif
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.h b/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.h
deleted file mode 100644
index 7e58bfa..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/linux-syscalls.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_LINUX_SYSCALL_H_
-#define UV_LINUX_SYSCALL_H_
-
-#undef  _GNU_SOURCE
-#define _GNU_SOURCE
-
-#include <stdint.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-
-#if defined(__alpha__)
-# define UV__O_CLOEXEC        0x200000
-#elif defined(__hppa__)
-# define UV__O_CLOEXEC        0x200000
-#elif defined(__sparc__)
-# define UV__O_CLOEXEC        0x400000
-#else
-# define UV__O_CLOEXEC        0x80000
-#endif
-
-#if defined(__alpha__)
-# define UV__O_NONBLOCK       0x4
-#elif defined(__hppa__)
-# define UV__O_NONBLOCK       O_NONBLOCK
-#elif defined(__mips__)
-# define UV__O_NONBLOCK       0x80
-#elif defined(__sparc__)
-# define UV__O_NONBLOCK       0x4000
-#else
-# define UV__O_NONBLOCK       0x800
-#endif
-
-#define UV__EFD_CLOEXEC       UV__O_CLOEXEC
-#define UV__EFD_NONBLOCK      UV__O_NONBLOCK
-
-#define UV__IN_CLOEXEC        UV__O_CLOEXEC
-#define UV__IN_NONBLOCK       UV__O_NONBLOCK
-
-#define UV__SOCK_CLOEXEC      UV__O_CLOEXEC
-#if defined(SOCK_NONBLOCK)
-# define UV__SOCK_NONBLOCK    SOCK_NONBLOCK
-#else
-# define UV__SOCK_NONBLOCK    UV__O_NONBLOCK
-#endif
-
-/* inotify flags */
-#define UV__IN_ACCESS         0x001
-#define UV__IN_MODIFY         0x002
-#define UV__IN_ATTRIB         0x004
-#define UV__IN_CLOSE_WRITE    0x008
-#define UV__IN_CLOSE_NOWRITE  0x010
-#define UV__IN_OPEN           0x020
-#define UV__IN_MOVED_FROM     0x040
-#define UV__IN_MOVED_TO       0x080
-#define UV__IN_CREATE         0x100
-#define UV__IN_DELETE         0x200
-#define UV__IN_DELETE_SELF    0x400
-#define UV__IN_MOVE_SELF      0x800
-
-struct uv__statx_timestamp {
-  int64_t tv_sec;
-  uint32_t tv_nsec;
-  int32_t unused0;
-};
-
-struct uv__statx {
-  uint32_t stx_mask;
-  uint32_t stx_blksize;
-  uint64_t stx_attributes;
-  uint32_t stx_nlink;
-  uint32_t stx_uid;
-  uint32_t stx_gid;
-  uint16_t stx_mode;
-  uint16_t unused0;
-  uint64_t stx_ino;
-  uint64_t stx_size;
-  uint64_t stx_blocks;
-  uint64_t stx_attributes_mask;
-  struct uv__statx_timestamp stx_atime;
-  struct uv__statx_timestamp stx_btime;
-  struct uv__statx_timestamp stx_ctime;
-  struct uv__statx_timestamp stx_mtime;
-  uint32_t stx_rdev_major;
-  uint32_t stx_rdev_minor;
-  uint32_t stx_dev_major;
-  uint32_t stx_dev_minor;
-  uint64_t unused1[14];
-};
-
-struct uv__inotify_event {
-  int32_t wd;
-  uint32_t mask;
-  uint32_t cookie;
-  uint32_t len;
-  /* char name[0]; */
-};
-
-struct uv__mmsghdr {
-  struct msghdr msg_hdr;
-  unsigned int msg_len;
-};
-
-int uv__accept4(int fd, struct sockaddr* addr, socklen_t* addrlen, int flags);
-int uv__eventfd(unsigned int count);
-int uv__eventfd2(unsigned int count, int flags);
-int uv__inotify_init(void);
-int uv__inotify_init1(int flags);
-int uv__inotify_add_watch(int fd, const char* path, uint32_t mask);
-int uv__inotify_rm_watch(int fd, int32_t wd);
-int uv__pipe2(int pipefd[2], int flags);
-int uv__recvmmsg(int fd,
-                 struct uv__mmsghdr* mmsg,
-                 unsigned int vlen,
-                 unsigned int flags,
-                 struct timespec* timeout);
-int uv__sendmmsg(int fd,
-                 struct uv__mmsghdr* mmsg,
-                 unsigned int vlen,
-                 unsigned int flags);
-ssize_t uv__preadv(int fd, const struct iovec *iov, int iovcnt, int64_t offset);
-ssize_t uv__pwritev(int fd, const struct iovec *iov, int iovcnt, int64_t offset);
-int uv__dup3(int oldfd, int newfd, int flags);
-int uv__statx(int dirfd,
-              const char* path,
-              int flags,
-              unsigned int mask,
-              struct uv__statx* statxbuf);
-
-#endif /* UV_LINUX_SYSCALL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/unix/loop-watcher.cpp b/wpiutil/src/main/native/libuv/src/unix/loop-watcher.cpp
deleted file mode 100644
index b8c1c2a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/loop-watcher.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#define UV_LOOP_WATCHER_DEFINE(name, type)                                    \
-  int uv_##name##_init(uv_loop_t* loop, uv_##name##_t* handle) {              \
-    uv__handle_init(loop, (uv_handle_t*)handle, UV_##type);                   \
-    handle->name##_cb = NULL;                                                 \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-  int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) {           \
-    if (uv__is_active(handle)) return 0;                                      \
-    if (cb == NULL) return UV_EINVAL;                                         \
-    QUEUE_INSERT_HEAD(&handle->loop->name##_handles, &handle->queue);         \
-    handle->name##_cb = cb;                                                   \
-    uv__handle_start(handle);                                                 \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-  int uv_##name##_stop(uv_##name##_t* handle) {                               \
-    if (!uv__is_active(handle)) return 0;                                     \
-    QUEUE_REMOVE(&handle->queue);                                             \
-    uv__handle_stop(handle);                                                  \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-  void uv__run_##name(uv_loop_t* loop) {                                      \
-    uv_##name##_t* h;                                                         \
-    QUEUE queue;                                                              \
-    QUEUE* q;                                                                 \
-    QUEUE_MOVE(&loop->name##_handles, &queue);                                \
-    while (!QUEUE_EMPTY(&queue)) {                                            \
-      q = QUEUE_HEAD(&queue);                                                 \
-      h = QUEUE_DATA(q, uv_##name##_t, queue);                                \
-      QUEUE_REMOVE(q);                                                        \
-      QUEUE_INSERT_TAIL(&loop->name##_handles, q);                            \
-      h->name##_cb(h);                                                        \
-    }                                                                         \
-  }                                                                           \
-                                                                              \
-  void uv__##name##_close(uv_##name##_t* handle) {                            \
-    uv_##name##_stop(handle);                                                 \
-  }
-
-UV_LOOP_WATCHER_DEFINE(prepare, PREPARE)
-UV_LOOP_WATCHER_DEFINE(check, CHECK)
-UV_LOOP_WATCHER_DEFINE(idle, IDLE)
diff --git a/wpiutil/src/main/native/libuv/src/unix/loop.cpp b/wpiutil/src/main/native/libuv/src/unix/loop.cpp
deleted file mode 100644
index 7a037d1..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/loop.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "uv/tree.h"
-#include "internal.h"
-#include "heap-inl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-int uv_loop_init(uv_loop_t* loop) {
-  void* saved_data;
-  int err;
-
-
-  saved_data = loop->data;
-  memset(loop, 0, sizeof(*loop));
-  loop->data = saved_data;
-
-  heap_init((struct heap*) &loop->timer_heap);
-  QUEUE_INIT(&loop->wq);
-  QUEUE_INIT(&loop->idle_handles);
-  QUEUE_INIT(&loop->async_handles);
-  QUEUE_INIT(&loop->check_handles);
-  QUEUE_INIT(&loop->prepare_handles);
-  QUEUE_INIT(&loop->handle_queue);
-
-  loop->active_handles = 0;
-  loop->active_reqs.count = 0;
-  loop->nfds = 0;
-  loop->watchers = NULL;
-  loop->nwatchers = 0;
-  QUEUE_INIT(&loop->pending_queue);
-  QUEUE_INIT(&loop->watcher_queue);
-
-  loop->closing_handles = NULL;
-  uv__update_time(loop);
-  loop->async_io_watcher.fd = -1;
-  loop->async_wfd = -1;
-  loop->signal_pipefd[0] = -1;
-  loop->signal_pipefd[1] = -1;
-  loop->backend_fd = -1;
-  loop->emfile_fd = -1;
-
-  loop->timer_counter = 0;
-  loop->stop_flag = 0;
-
-  err = uv__platform_loop_init(loop);
-  if (err)
-    return err;
-
-  uv__signal_global_once_init();
-  err = uv_signal_init(loop, &loop->child_watcher);
-  if (err)
-    goto fail_signal_init;
-
-  uv__handle_unref(&loop->child_watcher);
-  loop->child_watcher.flags |= UV_HANDLE_INTERNAL;
-  QUEUE_INIT(&loop->process_handles);
-
-  err = uv_rwlock_init(&loop->cloexec_lock);
-  if (err)
-    goto fail_rwlock_init;
-
-  err = uv_mutex_init(&loop->wq_mutex);
-  if (err)
-    goto fail_mutex_init;
-
-  err = uv_async_init(loop, &loop->wq_async, uv__work_done);
-  if (err)
-    goto fail_async_init;
-
-  uv__handle_unref(&loop->wq_async);
-  loop->wq_async.flags |= UV_HANDLE_INTERNAL;
-
-  return 0;
-
-fail_async_init:
-  uv_mutex_destroy(&loop->wq_mutex);
-
-fail_mutex_init:
-  uv_rwlock_destroy(&loop->cloexec_lock);
-
-fail_rwlock_init:
-  uv__signal_loop_cleanup(loop);
-
-fail_signal_init:
-  uv__platform_loop_delete(loop);
-
-  return err;
-}
-
-
-int uv_loop_fork(uv_loop_t* loop) {
-  int err;
-  unsigned int i;
-  uv__io_t* w;
-
-  err = uv__io_fork(loop);
-  if (err)
-    return err;
-
-  err = uv__async_fork(loop);
-  if (err)
-    return err;
-
-  err = uv__signal_loop_fork(loop);
-  if (err)
-    return err;
-
-  /* Rearm all the watchers that aren't re-queued by the above. */
-  for (i = 0; i < loop->nwatchers; i++) {
-    w = (uv__io_t*)loop->watchers[i];
-    if (w == NULL)
-      continue;
-
-    if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue)) {
-      w->events = 0; /* Force re-registration in uv__io_poll. */
-      QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
-    }
-  }
-
-  return 0;
-}
-
-
-void uv__loop_close(uv_loop_t* loop) {
-  uv__signal_loop_cleanup(loop);
-  uv__platform_loop_delete(loop);
-  uv__async_stop(loop);
-
-  if (loop->emfile_fd != -1) {
-    uv__close(loop->emfile_fd);
-    loop->emfile_fd = -1;
-  }
-
-  if (loop->backend_fd != -1) {
-    uv__close(loop->backend_fd);
-    loop->backend_fd = -1;
-  }
-
-  uv_mutex_lock(&loop->wq_mutex);
-  assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
-  assert(!uv__has_active_reqs(loop));
-  uv_mutex_unlock(&loop->wq_mutex);
-  uv_mutex_destroy(&loop->wq_mutex);
-
-  /*
-   * Note that all thread pool stuff is finished at this point and
-   * it is safe to just destroy rw lock
-   */
-  uv_rwlock_destroy(&loop->cloexec_lock);
-
-#if 0
-  assert(QUEUE_EMPTY(&loop->pending_queue));
-  assert(QUEUE_EMPTY(&loop->watcher_queue));
-  assert(loop->nfds == 0);
-#endif
-
-  uv__free(loop->watchers);
-  loop->watchers = NULL;
-  loop->nwatchers = 0;
-}
-
-
-int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap) {
-  if (option != UV_LOOP_BLOCK_SIGNAL)
-    return UV_ENOSYS;
-
-  if (va_arg(ap, int) != SIGPROF)
-    return UV_EINVAL;
-
-  loop->flags |= UV_LOOP_BLOCK_SIGPROF;
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/netbsd.cpp b/wpiutil/src/main/native/libuv/src/unix/netbsd.cpp
deleted file mode 100644
index fb89843..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/netbsd.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <string.h>
-#include <errno.h>
-
-#include <kvm.h>
-#include <paths.h>
-#include <unistd.h>
-#include <time.h>
-#include <stdlib.h>
-#include <fcntl.h>
-
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <uvm/uvm_extern.h>
-
-#include <unistd.h>
-#include <time.h>
-
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  return uv__kqueue_init(loop);
-}
-
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-}
-
-
-void uv_loadavg(double avg[3]) {
-  struct loadavg info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_LOADAVG};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0) == -1) return;
-
-  avg[0] = (double) info.ldavg[0] / info.fscale;
-  avg[1] = (double) info.ldavg[1] / info.fscale;
-  avg[2] = (double) info.ldavg[2] / info.fscale;
-}
-
-
-int uv_exepath(char* buffer, size_t* size) {
-  /* Intermediate buffer, retrieving partial path name does not work
-   * As of NetBSD-8(beta), vnode->path translator does not handle files
-   * with longer names than 31 characters.
-   */
-  char int_buf[PATH_MAX];
-  size_t int_size;
-  int mib[4];
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  mib[0] = CTL_KERN;
-  mib[1] = KERN_PROC_ARGS;
-  mib[2] = -1;
-  mib[3] = KERN_PROC_PATHNAME;
-  int_size = ARRAY_SIZE(int_buf);
-
-  if (sysctl(mib, 4, int_buf, &int_size, NULL, 0))
-    return UV__ERR(errno);
-
-  /* Copy string from the intermediate buffer to outer one with appropriate
-   * length.
-   */
-  /* TODO(bnoordhuis) Check uv__strscpy() return value. */
-  uv__strscpy(buffer, int_buf, *size);
-
-  /* Set new size. */
-  *size = strlen(buffer);
-
-  return 0;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  struct uvmexp info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_UVMEXP};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info.free * sysconf(_SC_PAGESIZE);
-}
-
-
-uint64_t uv_get_total_memory(void) {
-#if defined(HW_PHYSMEM64)
-  uint64_t info;
-  int which[] = {CTL_HW, HW_PHYSMEM64};
-#else
-  unsigned int info;
-  int which[] = {CTL_HW, HW_PHYSMEM};
-#endif
-  size_t size = sizeof(info);
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  kvm_t *kd = NULL;
-  struct kinfo_proc2 *kinfo = NULL;
-  pid_t pid;
-  int nprocs;
-  int max_size = sizeof(struct kinfo_proc2);
-  int page_size;
-
-  page_size = getpagesize();
-  pid = getpid();
-
-  kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, "kvm_open");
-
-  if (kd == NULL) goto error;
-
-  kinfo = kvm_getproc2(kd, KERN_PROC_PID, pid, max_size, &nprocs);
-  if (kinfo == NULL) goto error;
-
-  *rss = kinfo->p_vm_rssize * page_size;
-
-  kvm_close(kd);
-
-  return 0;
-
-error:
-  if (kd) kvm_close(kd);
-  return UV_EPERM;
-}
-
-
-int uv_uptime(double* uptime) {
-  time_t now;
-  struct timeval info;
-  size_t size = sizeof(info);
-  static int which[] = {CTL_KERN, KERN_BOOTTIME};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  now = time(NULL);
-
-  *uptime = (double)(now - info.tv_sec);
-  return 0;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK);
-  unsigned int multiplier = ((uint64_t)1000L / ticks);
-  unsigned int cur = 0;
-  uv_cpu_info_t* cpu_info;
-  u_int64_t* cp_times;
-  char model[512];
-  u_int64_t cpuspeed;
-  int numcpus;
-  size_t size;
-  int i;
-
-  size = sizeof(model);
-  if (sysctlbyname("machdep.cpu_brand", &model, &size, NULL, 0) &&
-      sysctlbyname("hw.model", &model, &size, NULL, 0)) {
-    return UV__ERR(errno);
-  }
-
-  size = sizeof(numcpus);
-  if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0))
-    return UV__ERR(errno);
-  *count = numcpus;
-
-  /* Only i386 and amd64 have machdep.tsc_freq */
-  size = sizeof(cpuspeed);
-  if (sysctlbyname("machdep.tsc_freq", &cpuspeed, &size, NULL, 0))
-    cpuspeed = 0;
-
-  size = numcpus * CPUSTATES * sizeof(*cp_times);
-  cp_times = (u_int64_t*)uv__malloc(size);
-  if (cp_times == NULL)
-    return UV_ENOMEM;
-
-  if (sysctlbyname("kern.cp_time", cp_times, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos));
-  if (!(*cpu_infos)) {
-    uv__free(cp_times);
-    uv__free(*cpu_infos);
-    return UV_ENOMEM;
-  }
-
-  for (i = 0; i < numcpus; i++) {
-    cpu_info = &(*cpu_infos)[i];
-    cpu_info->cpu_times.user = (uint64_t)(cp_times[CP_USER+cur]) * multiplier;
-    cpu_info->cpu_times.nice = (uint64_t)(cp_times[CP_NICE+cur]) * multiplier;
-    cpu_info->cpu_times.sys = (uint64_t)(cp_times[CP_SYS+cur]) * multiplier;
-    cpu_info->cpu_times.idle = (uint64_t)(cp_times[CP_IDLE+cur]) * multiplier;
-    cpu_info->cpu_times.irq = (uint64_t)(cp_times[CP_INTR+cur]) * multiplier;
-    cpu_info->model = uv__strdup(model);
-    cpu_info->speed = (int)(cpuspeed/(uint64_t) 1e6);
-    cur += CPUSTATES;
-  }
-  uv__free(cp_times);
-  return 0;
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/no-fsevents.cpp b/wpiutil/src/main/native/libuv/src/unix/no-fsevents.cpp
deleted file mode 100644
index 158643a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/no-fsevents.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <errno.h>
-
-int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
-  return UV_ENOSYS;
-}
-
-int uv_fs_event_start(uv_fs_event_t* handle, uv_fs_event_cb cb,
-                      const char* filename, unsigned int flags) {
-  return UV_ENOSYS;
-}
-
-int uv_fs_event_stop(uv_fs_event_t* handle) {
-  return UV_ENOSYS;
-}
-
-void uv__fs_event_close(uv_fs_event_t* handle) {
-  UNREACHABLE();
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/no-proctitle.cpp b/wpiutil/src/main/native/libuv/src/unix/no-proctitle.cpp
deleted file mode 100644
index 165740c..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/no-proctitle.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <errno.h>
-#include <stddef.h>
-
-char** uv_setup_args(int argc, char** argv) {
-  return argv;
-}
-
-int uv_set_process_title(const char* title) {
-  return 0;
-}
-
-int uv_get_process_title(char* buffer, size_t size) {
-  if (buffer == NULL || size == 0)
-    return UV_EINVAL;
-
-  buffer[0] = '\0';
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/openbsd.cpp b/wpiutil/src/main/native/libuv/src/unix/openbsd.cpp
deleted file mode 100644
index f13ad8c..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/openbsd.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/sched.h>
-#include <sys/time.h>
-#include <sys/sysctl.h>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <paths.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  return uv__kqueue_init(loop);
-}
-
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-}
-
-
-void uv_loadavg(double avg[3]) {
-  struct loadavg info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_LOADAVG};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0) < 0) return;
-
-  avg[0] = (double) info.ldavg[0] / info.fscale;
-  avg[1] = (double) info.ldavg[1] / info.fscale;
-  avg[2] = (double) info.ldavg[2] / info.fscale;
-}
-
-
-int uv_exepath(char* buffer, size_t* size) {
-  int mib[4];
-  char **argsbuf = NULL;
-  char **argsbuf_tmp;
-  size_t argsbuf_size = 100U;
-  size_t exepath_size;
-  pid_t mypid;
-  int err;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  mypid = getpid();
-  for (;;) {
-    err = UV_ENOMEM;
-    argsbuf_tmp = (char**)uv__realloc(argsbuf, argsbuf_size);
-    if (argsbuf_tmp == NULL)
-      goto out;
-    argsbuf = argsbuf_tmp;
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC_ARGS;
-    mib[2] = mypid;
-    mib[3] = KERN_PROC_ARGV;
-    if (sysctl(mib, 4, argsbuf, &argsbuf_size, NULL, 0) == 0) {
-      break;
-    }
-    if (errno != ENOMEM) {
-      err = UV__ERR(errno);
-      goto out;
-    }
-    argsbuf_size *= 2U;
-  }
-
-  if (argsbuf[0] == NULL) {
-    err = UV_EINVAL;  /* FIXME(bnoordhuis) More appropriate error. */
-    goto out;
-  }
-
-  *size -= 1;
-  exepath_size = strlen(argsbuf[0]);
-  if (*size > exepath_size)
-    *size = exepath_size;
-
-  memcpy(buffer, argsbuf[0], *size);
-  buffer[*size] = '\0';
-  err = 0;
-
-out:
-  uv__free(argsbuf);
-
-  return err;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  struct uvmexp info;
-  size_t size = sizeof(info);
-  int which[] = {CTL_VM, VM_UVMEXP};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info.free * sysconf(_SC_PAGESIZE);
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  uint64_t info;
-  int which[] = {CTL_HW, HW_PHYSMEM64};
-  size_t size = sizeof(info);
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  return (uint64_t) info;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  struct kinfo_proc kinfo;
-  size_t page_size = getpagesize();
-  size_t size = sizeof(struct kinfo_proc);
-  int mib[6];
-
-  mib[0] = CTL_KERN;
-  mib[1] = KERN_PROC;
-  mib[2] = KERN_PROC_PID;
-  mib[3] = getpid();
-  mib[4] = sizeof(struct kinfo_proc);
-  mib[5] = 1;
-
-  if (sysctl(mib, 6, &kinfo, &size, NULL, 0) < 0)
-    return UV__ERR(errno);
-
-  *rss = kinfo.p_vm_rssize * page_size;
-  return 0;
-}
-
-
-int uv_uptime(double* uptime) {
-  time_t now;
-  struct timeval info;
-  size_t size = sizeof(info);
-  static int which[] = {CTL_KERN, KERN_BOOTTIME};
-
-  if (sysctl(which, 2, &info, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  now = time(NULL);
-
-  *uptime = (double)(now - info.tv_sec);
-  return 0;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {
-  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),
-               multiplier = ((uint64_t)1000L / ticks), cpuspeed;
-  uint64_t info[CPUSTATES];
-  char model[512];
-  int numcpus = 1;
-  int which[] = {CTL_HW,HW_MODEL,0};
-  size_t size;
-  int i;
-  uv_cpu_info_t* cpu_info;
-
-  size = sizeof(model);
-  if (sysctl(which, 2, &model, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  which[1] = HW_NCPU;
-  size = sizeof(numcpus);
-  if (sysctl(which, 2, &numcpus, &size, NULL, 0))
-    return UV__ERR(errno);
-
-  *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos));
-  if (!(*cpu_infos))
-    return UV_ENOMEM;
-
-  *count = numcpus;
-
-  which[1] = HW_CPUSPEED;
-  size = sizeof(cpuspeed);
-  if (sysctl(which, 2, &cpuspeed, &size, NULL, 0)) {
-    uv__free(*cpu_infos);
-    return UV__ERR(errno);
-  }
-
-  size = sizeof(info);
-  which[0] = CTL_KERN;
-  which[1] = KERN_CPTIME2;
-  for (i = 0; i < numcpus; i++) {
-    which[2] = i;
-    size = sizeof(info);
-    if (sysctl(which, 3, &info, &size, NULL, 0)) {
-      uv__free(*cpu_infos);
-      return UV__ERR(errno);
-    }
-
-    cpu_info = &(*cpu_infos)[i];
-
-    cpu_info->cpu_times.user = (uint64_t)(info[CP_USER]) * multiplier;
-    cpu_info->cpu_times.nice = (uint64_t)(info[CP_NICE]) * multiplier;
-    cpu_info->cpu_times.sys = (uint64_t)(info[CP_SYS]) * multiplier;
-    cpu_info->cpu_times.idle = (uint64_t)(info[CP_IDLE]) * multiplier;
-    cpu_info->cpu_times.irq = (uint64_t)(info[CP_INTR]) * multiplier;
-
-    cpu_info->model = uv__strdup(model);
-    cpu_info->speed = cpuspeed;
-  }
-
-  return 0;
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/pipe.cpp b/wpiutil/src/main/native/libuv/src/unix/pipe.cpp
deleted file mode 100644
index c21033a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/pipe.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/un.h>
-#include <unistd.h>
-#include <stdlib.h>
-
-
-int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
-  uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
-  handle->shutdown_req = NULL;
-  handle->connect_req = NULL;
-  handle->pipe_fname = NULL;
-  handle->ipc = ipc;
-  return 0;
-}
-
-
-int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
-  struct sockaddr_un saddr;
-  const char* pipe_fname;
-  int sockfd;
-  int err;
-
-  pipe_fname = NULL;
-
-  /* Already bound? */
-  if (uv__stream_fd(handle) >= 0)
-    return UV_EINVAL;
-
-  /* Make a copy of the file name, it outlives this function's scope. */
-  pipe_fname = uv__strdup(name);
-  if (pipe_fname == NULL)
-    return UV_ENOMEM;
-
-  /* We've got a copy, don't touch the original any more. */
-  name = NULL;
-
-  err = uv__socket(AF_UNIX, SOCK_STREAM, 0);
-  if (err < 0)
-    goto err_socket;
-  sockfd = err;
-
-  memset(&saddr, 0, sizeof saddr);
-  uv__strscpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path));
-  saddr.sun_family = AF_UNIX;
-
-  if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr)) {
-    err = UV__ERR(errno);
-    /* Convert ENOENT to EACCES for compatibility with Windows. */
-    if (err == UV_ENOENT)
-      err = UV_EACCES;
-
-    uv__close(sockfd);
-    goto err_socket;
-  }
-
-  /* Success. */
-  handle->flags |= UV_HANDLE_BOUND;
-  handle->pipe_fname = pipe_fname; /* Is a strdup'ed copy. */
-  handle->io_watcher.fd = sockfd;
-  return 0;
-
-err_socket:
-  uv__free((void*)pipe_fname);
-  return err;
-}
-
-
-int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
-  if (uv__stream_fd(handle) == -1)
-    return UV_EINVAL;
-
-#if defined(__MVS__)
-  /* On zOS, backlog=0 has undefined behaviour */
-  if (backlog == 0)
-    backlog = 1;
-  else if (backlog < 0)
-    backlog = SOMAXCONN;
-#endif
-
-  if (listen(uv__stream_fd(handle), backlog))
-    return UV__ERR(errno);
-
-  handle->connection_cb = cb;
-  handle->io_watcher.cb = uv__server_io;
-  uv__io_start(handle->loop, &handle->io_watcher, POLLIN);
-  return 0;
-}
-
-
-void uv__pipe_close(uv_pipe_t* handle) {
-  if (handle->pipe_fname) {
-    /*
-     * Unlink the file system entity before closing the file descriptor.
-     * Doing it the other way around introduces a race where our process
-     * unlinks a socket with the same name that's just been created by
-     * another thread or process.
-     */
-    unlink(handle->pipe_fname);
-    uv__free((void*)handle->pipe_fname);
-    handle->pipe_fname = NULL;
-  }
-
-  uv__stream_close((uv_stream_t*)handle);
-}
-
-
-int uv_pipe_open(uv_pipe_t* handle, uv_file fd) {
-  int flags;
-  int mode;
-  int err;
-  flags = 0;
-
-  if (uv__fd_exists(handle->loop, fd))
-    return UV_EEXIST;
-
-  do
-    mode = fcntl(fd, F_GETFL);
-  while (mode == -1 && errno == EINTR);
-
-  if (mode == -1)
-    return UV__ERR(errno); /* according to docs, must be EBADF */
-
-  err = uv__nonblock(fd, 1);
-  if (err)
-    return err;
-
-#if defined(__APPLE__)
-  err = uv__stream_try_select((uv_stream_t*) handle, &fd);
-  if (err)
-    return err;
-#endif /* defined(__APPLE__) */
-
-  mode &= O_ACCMODE;
-  if (mode != O_WRONLY)
-    flags |= UV_HANDLE_READABLE;
-  if (mode != O_RDONLY)
-    flags |= UV_HANDLE_WRITABLE;
-
-  return uv__stream_open((uv_stream_t*)handle, fd, flags);
-}
-
-
-void uv_pipe_connect(uv_connect_t* req,
-                    uv_pipe_t* handle,
-                    const char* name,
-                    uv_connect_cb cb) {
-  struct sockaddr_un saddr;
-  int new_sock;
-  int err;
-  int r;
-
-  new_sock = (uv__stream_fd(handle) == -1);
-
-  if (new_sock) {
-    err = uv__socket(AF_UNIX, SOCK_STREAM, 0);
-    if (err < 0)
-      goto out;
-    handle->io_watcher.fd = err;
-  }
-
-  memset(&saddr, 0, sizeof saddr);
-  uv__strscpy(saddr.sun_path, name, sizeof(saddr.sun_path));
-  saddr.sun_family = AF_UNIX;
-
-  do {
-    r = connect(uv__stream_fd(handle),
-                (struct sockaddr*)&saddr, sizeof saddr);
-  }
-  while (r == -1 && errno == EINTR);
-
-  if (r == -1 && errno != EINPROGRESS) {
-    err = UV__ERR(errno);
-#if defined(__CYGWIN__) || defined(__MSYS__)
-    /* EBADF is supposed to mean that the socket fd is bad, but
-       Cygwin reports EBADF instead of ENOTSOCK when the file is
-       not a socket.  We do not expect to see a bad fd here
-       (e.g. due to new_sock), so translate the error.  */
-    if (err == UV_EBADF)
-      err = UV_ENOTSOCK;
-#endif
-    goto out;
-  }
-
-  err = 0;
-  if (new_sock) {
-    err = uv__stream_open((uv_stream_t*)handle,
-                          uv__stream_fd(handle),
-                          UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-  }
-
-  if (err == 0)
-    uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
-
-out:
-  handle->delayed_error = err;
-  handle->connect_req = req;
-
-  uv__req_init(handle->loop, req, UV_CONNECT);
-  req->handle = (uv_stream_t*)handle;
-  req->cb = cb;
-  QUEUE_INIT(&req->queue);
-
-  /* Force callback to run on next tick in case of error. */
-  if (err)
-    uv__io_feed(handle->loop, &handle->io_watcher);
-
-}
-
-
-static int uv__pipe_getsockpeername(const uv_pipe_t* handle,
-                                    uv__peersockfunc func,
-                                    char* buffer,
-                                    size_t* size) {
-  struct sockaddr_un sa;
-  socklen_t addrlen;
-  int err;
-
-  addrlen = sizeof(sa);
-  memset(&sa, 0, addrlen);
-  err = uv__getsockpeername((const uv_handle_t*) handle,
-                            func,
-                            (struct sockaddr*) &sa,
-                            (int*) &addrlen);
-  if (err < 0) {
-    *size = 0;
-    return err;
-  }
-
-#if defined(__linux__)
-  if (sa.sun_path[0] == 0)
-    /* Linux abstract namespace */
-    addrlen -= offsetof(struct sockaddr_un, sun_path);
-  else
-#endif
-    addrlen = strlen(sa.sun_path);
-
-
-  if (addrlen >= *size) {
-    *size = addrlen + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, sa.sun_path, addrlen);
-  *size = addrlen;
-
-  /* only null-terminate if it's not an abstract socket */
-  if (buffer[0] != '\0')
-    buffer[addrlen] = '\0';
-
-  return 0;
-}
-
-
-int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size) {
-  return uv__pipe_getsockpeername(handle, getsockname, buffer, size);
-}
-
-
-int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size) {
-  return uv__pipe_getsockpeername(handle, getpeername, buffer, size);
-}
-
-
-void uv_pipe_pending_instances(uv_pipe_t* handle, int count) {
-}
-
-
-int uv_pipe_pending_count(uv_pipe_t* handle) {
-  uv__stream_queued_fds_t* queued_fds;
-
-  if (!handle->ipc)
-    return 0;
-
-  if (handle->accepted_fd == -1)
-    return 0;
-
-  if (handle->queued_fds == NULL)
-    return 1;
-
-  queued_fds = (uv__stream_queued_fds_t*)(handle->queued_fds);
-  return queued_fds->offset + 1;
-}
-
-
-uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle) {
-  if (!handle->ipc)
-    return UV_UNKNOWN_HANDLE;
-
-  if (handle->accepted_fd == -1)
-    return UV_UNKNOWN_HANDLE;
-  else
-    return uv__handle_type(handle->accepted_fd);
-}
-
-
-int uv_pipe_chmod(uv_pipe_t* handle, int mode) {
-  unsigned desired_mode;
-  struct stat pipe_stat;
-  char* name_buffer;
-  size_t name_len;
-  int r;
-
-  if (handle == NULL || uv__stream_fd(handle) == -1)
-    return UV_EBADF;
-
-  if (mode != UV_READABLE &&
-      mode != UV_WRITABLE &&
-      mode != (UV_WRITABLE | UV_READABLE))
-    return UV_EINVAL;
-
-  /* Unfortunately fchmod does not work on all platforms, we will use chmod. */
-  name_len = 0;
-  r = uv_pipe_getsockname(handle, NULL, &name_len);
-  if (r != UV_ENOBUFS)
-    return r;
-
-  name_buffer = (char*)uv__malloc(name_len);
-  if (name_buffer == NULL)
-    return UV_ENOMEM;
-
-  r = uv_pipe_getsockname(handle, name_buffer, &name_len);
-  if (r != 0) {
-    uv__free(name_buffer);
-    return r;
-  }
-
-  /* stat must be used as fstat has a bug on Darwin */
-  if (stat(name_buffer, &pipe_stat) == -1) {
-    uv__free(name_buffer);
-    return -errno;
-  }
-
-  desired_mode = 0;
-  if (mode & UV_READABLE)
-    desired_mode |= S_IRUSR | S_IRGRP | S_IROTH;
-  if (mode & UV_WRITABLE)
-    desired_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
-
-  /* Exit early if pipe already has desired mode. */
-  if ((pipe_stat.st_mode & desired_mode) == desired_mode) {
-    uv__free(name_buffer);
-    return 0;
-  }
-
-  pipe_stat.st_mode |= desired_mode;
-
-  r = chmod(name_buffer, pipe_stat.st_mode);
-  uv__free(name_buffer);
-
-  return r != -1 ? 0 : UV__ERR(errno);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/poll.cpp b/wpiutil/src/main/native/libuv/src/unix/poll.cpp
deleted file mode 100644
index d578611..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/poll.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <unistd.h>
-#include <assert.h>
-#include <errno.h>
-
-
-static void uv__poll_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  uv_poll_t* handle;
-  int pevents;
-
-  handle = container_of(w, uv_poll_t, io_watcher);
-
-  /*
-   * As documented in the kernel source fs/kernfs/file.c #780
-   * poll will return POLLERR|POLLPRI in case of sysfs
-   * polling. This does not happen in case of out-of-band
-   * TCP messages.
-   *
-   * The above is the case on (at least) FreeBSD and Linux.
-   *
-   * So to properly determine a POLLPRI or a POLLERR we need
-   * to check for both.
-   */
-  if ((events & POLLERR) && !(events & UV__POLLPRI)) {
-    uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
-    uv__handle_stop(handle);
-    handle->poll_cb(handle, UV_EBADF, 0);
-    return;
-  }
-
-  pevents = 0;
-  if (events & POLLIN)
-    pevents |= UV_READABLE;
-  if (events & UV__POLLPRI)
-    pevents |= UV_PRIORITIZED;
-  if (events & POLLOUT)
-    pevents |= UV_WRITABLE;
-  if (events & UV__POLLRDHUP)
-    pevents |= UV_DISCONNECT;
-
-  handle->poll_cb(handle, 0, pevents);
-}
-
-
-int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {
-  int err;
-
-  if (uv__fd_exists(loop, fd))
-    return UV_EEXIST;
-
-  err = uv__io_check_fd(loop, fd);
-  if (err)
-    return err;
-
-  /* If ioctl(FIONBIO) reports ENOTTY, try fcntl(F_GETFL) + fcntl(F_SETFL).
-   * Workaround for e.g. kqueue fds not supporting ioctls.
-   */
-  err = uv__nonblock(fd, 1);
-#ifdef UV__NONBLOCK_IS_IOCTL
-  if (err == UV_ENOTTY)
-    err = uv__nonblock_fcntl(fd, 1);
-#endif
-
-  if (err)
-    return err;
-
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
-  uv__io_init(&handle->io_watcher, uv__poll_io, fd);
-  handle->poll_cb = NULL;
-  return 0;
-}
-
-
-int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
-    uv_os_sock_t socket) {
-  return uv_poll_init(loop, handle, socket);
-}
-
-
-static void uv__poll_stop(uv_poll_t* handle) {
-  uv__io_stop(handle->loop,
-              &handle->io_watcher,
-              POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
-  uv__handle_stop(handle);
-  uv__platform_invalidate_fd(handle->loop, handle->io_watcher.fd);
-}
-
-
-int uv_poll_stop(uv_poll_t* handle) {
-  assert(!uv__is_closing(handle));
-  uv__poll_stop(handle);
-  return 0;
-}
-
-
-int uv_poll_start(uv_poll_t* handle, int pevents, uv_poll_cb poll_cb) {
-  int events;
-
-  assert((pevents & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT |
-                      UV_PRIORITIZED)) == 0);
-  assert(!uv__is_closing(handle));
-
-  uv__poll_stop(handle);
-
-  if (pevents == 0)
-    return 0;
-
-  events = 0;
-  if (pevents & UV_READABLE)
-    events |= POLLIN;
-  if (pevents & UV_PRIORITIZED)
-    events |= UV__POLLPRI;
-  if (pevents & UV_WRITABLE)
-    events |= POLLOUT;
-  if (pevents & UV_DISCONNECT)
-    events |= UV__POLLRDHUP;
-
-  uv__io_start(handle->loop, &handle->io_watcher, events);
-  uv__handle_start(handle);
-  handle->poll_cb = poll_cb;
-
-  return 0;
-}
-
-
-void uv__poll_close(uv_poll_t* handle) {
-  uv__poll_stop(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/posix-hrtime.cpp b/wpiutil/src/main/native/libuv/src/unix/posix-hrtime.cpp
deleted file mode 100644
index 323dfc2..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/posix-hrtime.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdint.h>
-#include <time.h>
-
-#undef NANOSEC
-#define NANOSEC ((uint64_t) 1e9)
-
-uint64_t uv__hrtime(uv_clocktype_t type) {
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  return (((uint64_t) ts.tv_sec) * NANOSEC + ts.tv_nsec);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/posix-poll.cpp b/wpiutil/src/main/native/libuv/src/unix/posix-poll.cpp
deleted file mode 100644
index b932f91..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/posix-poll.cpp
+++ /dev/null
@@ -1,336 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-/* POSIX defines poll() as a portable way to wait on file descriptors.
- * Here we maintain a dynamically sized array of file descriptors and
- * events to pass as the first argument to poll().
- */
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <errno.h>
-#include <unistd.h>
-
-int uv__platform_loop_init(uv_loop_t* loop) {
-  loop->poll_fds = NULL;
-  loop->poll_fds_used = 0;
-  loop->poll_fds_size = 0;
-  loop->poll_fds_iterating = 0;
-  return 0;
-}
-
-void uv__platform_loop_delete(uv_loop_t* loop) {
-  uv__free(loop->poll_fds);
-  loop->poll_fds = NULL;
-}
-
-int uv__io_fork(uv_loop_t* loop) {
-  uv__platform_loop_delete(loop);
-  return uv__platform_loop_init(loop);
-}
-
-/* Allocate or dynamically resize our poll fds array.  */
-static void uv__pollfds_maybe_resize(uv_loop_t* loop) {
-  size_t i;
-  size_t n;
-  struct pollfd* p;
-
-  if (loop->poll_fds_used < loop->poll_fds_size)
-    return;
-
-  n = loop->poll_fds_size ? loop->poll_fds_size * 2 : 64;
-  p = (struct pollfd*)uv__realloc(loop->poll_fds, n * sizeof(*loop->poll_fds));
-  if (p == NULL)
-    abort();
-
-  loop->poll_fds = p;
-  for (i = loop->poll_fds_size; i < n; i++) {
-    loop->poll_fds[i].fd = -1;
-    loop->poll_fds[i].events = 0;
-    loop->poll_fds[i].revents = 0;
-  }
-  loop->poll_fds_size = n;
-}
-
-/* Primitive swap operation on poll fds array elements.  */
-static void uv__pollfds_swap(uv_loop_t* loop, size_t l, size_t r) {
-  struct pollfd pfd;
-  pfd = loop->poll_fds[l];
-  loop->poll_fds[l] = loop->poll_fds[r];
-  loop->poll_fds[r] = pfd;
-}
-
-/* Add a watcher's fd to our poll fds array with its pending events.  */
-static void uv__pollfds_add(uv_loop_t* loop, uv__io_t* w) {
-  size_t i;
-  struct pollfd* pe;
-
-  /* If the fd is already in the set just update its events.  */
-  assert(!loop->poll_fds_iterating);
-  for (i = 0; i < loop->poll_fds_used; ++i) {
-    if (loop->poll_fds[i].fd == w->fd) {
-      loop->poll_fds[i].events = w->pevents;
-      return;
-    }
-  }
-
-  /* Otherwise, allocate a new slot in the set for the fd.  */
-  uv__pollfds_maybe_resize(loop);
-  pe = &loop->poll_fds[loop->poll_fds_used++];
-  pe->fd = w->fd;
-  pe->events = w->pevents;
-}
-
-/* Remove a watcher's fd from our poll fds array.  */
-static void uv__pollfds_del(uv_loop_t* loop, int fd) {
-  size_t i;
-  assert(!loop->poll_fds_iterating);
-  for (i = 0; i < loop->poll_fds_used;) {
-    if (loop->poll_fds[i].fd == fd) {
-      /* swap to last position and remove */
-      --loop->poll_fds_used;
-      uv__pollfds_swap(loop, i, loop->poll_fds_used);
-      loop->poll_fds[loop->poll_fds_used].fd = -1;
-      loop->poll_fds[loop->poll_fds_used].events = 0;
-      loop->poll_fds[loop->poll_fds_used].revents = 0;
-      /* This method is called with an fd of -1 to purge the invalidated fds,
-       * so we may possibly have multiples to remove.
-       */
-      if (-1 != fd)
-        return;
-    } else {
-      /* We must only increment the loop counter when the fds do not match.
-       * Otherwise, when we are purging an invalidated fd, the value just
-       * swapped here from the previous end of the array will be skipped.
-       */
-       ++i;
-    }
-  }
-}
-
-
-void uv__io_poll(uv_loop_t* loop, int timeout) {
-  sigset_t* pset;
-  sigset_t set;
-  uint64_t time_base;
-  uint64_t time_diff;
-  QUEUE* q;
-  uv__io_t* w;
-  size_t i;
-  unsigned int nevents;
-  int nfds;
-  int have_signals;
-  struct pollfd* pe;
-  int fd;
-
-  if (loop->nfds == 0) {
-    assert(QUEUE_EMPTY(&loop->watcher_queue));
-    return;
-  }
-
-  /* Take queued watchers and add their fds to our poll fds array.  */
-  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
-    q = QUEUE_HEAD(&loop->watcher_queue);
-    QUEUE_REMOVE(q);
-    QUEUE_INIT(q);
-
-    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
-    assert(w->pevents != 0);
-    assert(w->fd >= 0);
-    assert(w->fd < (int) loop->nwatchers);
-
-    uv__pollfds_add(loop, w);
-
-    w->events = w->pevents;
-  }
-
-  /* Prepare a set of signals to block around poll(), if any.  */
-  pset = NULL;
-  if (loop->flags & UV_LOOP_BLOCK_SIGPROF) {
-    pset = &set;
-    sigemptyset(pset);
-    sigaddset(pset, SIGPROF);
-  }
-
-  assert(timeout >= -1);
-  time_base = loop->time;
-
-  /* Loop calls to poll() and processing of results.  If we get some
-   * results from poll() but they turn out not to be interesting to
-   * our caller then we need to loop around and poll() again.
-   */
-  for (;;) {
-    if (pset != NULL)
-      if (pthread_sigmask(SIG_BLOCK, pset, NULL))
-        abort();
-    nfds = poll(loop->poll_fds, (nfds_t)loop->poll_fds_used, timeout);
-    if (pset != NULL)
-      if (pthread_sigmask(SIG_UNBLOCK, pset, NULL))
-        abort();
-
-    /* Update loop->time unconditionally. It's tempting to skip the update when
-     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
-     * operating system didn't reschedule our process while in the syscall.
-     */
-    SAVE_ERRNO(uv__update_time(loop));
-
-    if (nfds == 0) {
-      assert(timeout != -1);
-      return;
-    }
-
-    if (nfds == -1) {
-      if (errno != EINTR)
-        abort();
-
-      if (timeout == -1)
-        continue;
-
-      if (timeout == 0)
-        return;
-
-      /* Interrupted by a signal. Update timeout and poll again. */
-      goto update_timeout;
-    }
-
-    /* Tell uv__platform_invalidate_fd not to manipulate our array
-     * while we are iterating over it.
-     */
-    loop->poll_fds_iterating = 1;
-
-    /* Initialize a count of events that we care about.  */
-    nevents = 0;
-    have_signals = 0;
-
-    /* Loop over the entire poll fds array looking for returned events.  */
-    for (i = 0; i < loop->poll_fds_used; i++) {
-      pe = loop->poll_fds + i;
-      fd = pe->fd;
-
-      /* Skip invalidated events, see uv__platform_invalidate_fd.  */
-      if (fd == -1)
-        continue;
-
-      assert(fd >= 0);
-      assert((unsigned) fd < loop->nwatchers);
-
-      w = loop->watchers[fd];
-
-      if (w == NULL) {
-        /* File descriptor that we've stopped watching, ignore.  */
-        uv__platform_invalidate_fd(loop, fd);
-        continue;
-      }
-
-      /* Filter out events that user has not requested us to watch
-       * (e.g. POLLNVAL).
-       */
-      pe->revents &= w->pevents | POLLERR | POLLHUP;
-
-      if (pe->revents != 0) {
-        /* Run signal watchers last.  */
-        if (w == &loop->signal_io_watcher) {
-          have_signals = 1;
-        } else {
-          w->cb(loop, w, pe->revents);
-        }
-
-        nevents++;
-      }
-    }
-
-    if (have_signals != 0)
-      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
-
-    loop->poll_fds_iterating = 0;
-
-    /* Purge invalidated fds from our poll fds array.  */
-    uv__pollfds_del(loop, -1);
-
-    if (have_signals != 0)
-      return;  /* Event loop should cycle now so don't poll again. */
-
-    if (nevents != 0)
-      return;
-
-    if (timeout == 0)
-      return;
-
-    if (timeout == -1)
-      continue;
-
-update_timeout:
-    assert(timeout > 0);
-
-    time_diff = loop->time - time_base;
-    if (time_diff >= (uint64_t) timeout)
-      return;
-
-    timeout -= time_diff;
-  }
-}
-
-/* Remove the given fd from our poll fds array because no one
- * is interested in its events anymore.
- */
-void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) {
-  size_t i;
-
-  assert(fd >= 0);
-
-  if (loop->poll_fds_iterating) {
-    /* uv__io_poll is currently iterating.  Just invalidate fd.  */
-    for (i = 0; i < loop->poll_fds_used; i++)
-      if (loop->poll_fds[i].fd == fd) {
-        loop->poll_fds[i].fd = -1;
-        loop->poll_fds[i].events = 0;
-        loop->poll_fds[i].revents = 0;
-      }
-  } else {
-    /* uv__io_poll is not iterating.  Delete fd from the set.  */
-    uv__pollfds_del(loop, fd);
-  }
-}
-
-/* Check whether the given fd is supported by poll().  */
-int uv__io_check_fd(uv_loop_t* loop, int fd) {
-  struct pollfd p[1];
-  int rv;
-
-  p[0].fd = fd;
-  p[0].events = POLLIN;
-
-  do
-    rv = poll(p, 1, 0);
-  while (rv == -1 && (errno == EINTR || errno == EAGAIN));
-
-  if (rv == -1)
-    return UV__ERR(errno);
-
-  if (p[0].revents & POLLNVAL)
-    return UV_EINVAL;
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/process.cpp b/wpiutil/src/main/native/libuv/src/unix/process.cpp
deleted file mode 100644
index 87dac7f..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/process.cpp
+++ /dev/null
@@ -1,603 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <poll.h>
-
-#if defined(__APPLE__) && !TARGET_OS_IPHONE
-# include <crt_externs.h>
-# define environ (*_NSGetEnviron())
-#else
-extern char **environ;
-#endif
-
-#if defined(__linux__) || defined(__GLIBC__)
-# include <grp.h>
-#endif
-
-
-static void uv__chld(uv_signal_t* handle, int signum) {
-  uv_process_t* process;
-  uv_loop_t* loop;
-  int exit_status;
-  int term_signal;
-  int status;
-  pid_t pid;
-  QUEUE pending;
-  QUEUE* q;
-  QUEUE* h;
-
-  assert(signum == SIGCHLD);
-
-  QUEUE_INIT(&pending);
-  loop = handle->loop;
-
-  h = &loop->process_handles;
-  q = QUEUE_HEAD(h);
-  while (q != h) {
-    process = QUEUE_DATA(q, uv_process_t, queue);
-    q = QUEUE_NEXT(q);
-
-    do
-      pid = waitpid(process->pid, &status, WNOHANG);
-    while (pid == -1 && errno == EINTR);
-
-    if (pid == 0)
-      continue;
-
-    if (pid == -1) {
-      if (errno != ECHILD)
-        abort();
-      continue;
-    }
-
-    process->status = status;
-    QUEUE_REMOVE(&process->queue);
-    QUEUE_INSERT_TAIL(&pending, &process->queue);
-  }
-
-  h = &pending;
-  q = QUEUE_HEAD(h);
-  while (q != h) {
-    process = QUEUE_DATA(q, uv_process_t, queue);
-    q = QUEUE_NEXT(q);
-
-    QUEUE_REMOVE(&process->queue);
-    QUEUE_INIT(&process->queue);
-    uv__handle_stop(process);
-
-    if (process->exit_cb == NULL)
-      continue;
-
-    exit_status = 0;
-    if (WIFEXITED(process->status))
-      exit_status = WEXITSTATUS(process->status);
-
-    term_signal = 0;
-    if (WIFSIGNALED(process->status))
-      term_signal = WTERMSIG(process->status);
-
-    process->exit_cb(process, exit_status, term_signal);
-  }
-  assert(QUEUE_EMPTY(&pending));
-}
-
-
-int uv__make_socketpair(int fds[2], int flags) {
-#if defined(__linux__)
-  static int no_cloexec;
-
-  if (no_cloexec)
-    goto skip;
-
-  if (socketpair(AF_UNIX, SOCK_STREAM | UV__SOCK_CLOEXEC | flags, 0, fds) == 0)
-    return 0;
-
-  /* Retry on EINVAL, it means SOCK_CLOEXEC is not supported.
-   * Anything else is a genuine error.
-   */
-  if (errno != EINVAL)
-    return UV__ERR(errno);
-
-  no_cloexec = 1;
-
-skip:
-#endif
-
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
-    return UV__ERR(errno);
-
-  uv__cloexec(fds[0], 1);
-  uv__cloexec(fds[1], 1);
-
-  if (flags & UV__F_NONBLOCK) {
-    uv__nonblock(fds[0], 1);
-    uv__nonblock(fds[1], 1);
-  }
-
-  return 0;
-}
-
-
-int uv__make_pipe(int fds[2], int flags) {
-#if defined(__linux__)
-  static int no_pipe2;
-
-  if (no_pipe2)
-    goto skip;
-
-  if (uv__pipe2(fds, flags | UV__O_CLOEXEC) == 0)
-    return 0;
-
-  if (errno != ENOSYS)
-    return UV__ERR(errno);
-
-  no_pipe2 = 1;
-
-skip:
-#endif
-
-  if (pipe(fds))
-    return UV__ERR(errno);
-
-  uv__cloexec(fds[0], 1);
-  uv__cloexec(fds[1], 1);
-
-  if (flags & UV__F_NONBLOCK) {
-    uv__nonblock(fds[0], 1);
-    uv__nonblock(fds[1], 1);
-  }
-
-  return 0;
-}
-
-
-/*
- * Used for initializing stdio streams like options.stdin_stream. Returns
- * zero on success. See also the cleanup section in uv_spawn().
- */
-static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2]) {
-  int mask;
-  int fd;
-
-  mask = UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD | UV_INHERIT_STREAM;
-
-  switch (container->flags & mask) {
-  case UV_IGNORE:
-    return 0;
-
-  case UV_CREATE_PIPE:
-    assert(container->data.stream != NULL);
-    if (container->data.stream->type != UV_NAMED_PIPE)
-      return UV_EINVAL;
-    else
-      return uv__make_socketpair(fds, 0);
-
-  case UV_INHERIT_FD:
-  case UV_INHERIT_STREAM:
-    if (container->flags & UV_INHERIT_FD)
-      fd = container->data.fd;
-    else
-      fd = uv__stream_fd(container->data.stream);
-
-    if (fd == -1)
-      return UV_EINVAL;
-
-    fds[1] = fd;
-    return 0;
-
-  default:
-    assert(0 && "Unexpected flags");
-    return UV_EINVAL;
-  }
-}
-
-
-static int uv__process_open_stream(uv_stdio_container_t* container,
-                                   int pipefds[2]) {
-  int flags;
-  int err;
-
-  if (!(container->flags & UV_CREATE_PIPE) || pipefds[0] < 0)
-    return 0;
-
-  err = uv__close(pipefds[1]);
-  if (err != 0)
-    abort();
-
-  pipefds[1] = -1;
-  uv__nonblock(pipefds[0], 1);
-
-  flags = 0;
-  if (container->flags & UV_WRITABLE_PIPE)
-    flags |= UV_HANDLE_READABLE;
-  if (container->flags & UV_READABLE_PIPE)
-    flags |= UV_HANDLE_WRITABLE;
-
-  return uv__stream_open(container->data.stream, pipefds[0], flags);
-}
-
-
-static void uv__process_close_stream(uv_stdio_container_t* container) {
-  if (!(container->flags & UV_CREATE_PIPE)) return;
-  uv__stream_close(container->data.stream);
-}
-
-
-static void uv__write_int(int fd, int val) {
-  ssize_t n;
-
-  do
-    n = write(fd, &val, sizeof(val));
-  while (n == -1 && errno == EINTR);
-
-  if (n == -1 && errno == EPIPE)
-    return; /* parent process has quit */
-
-  assert(n == sizeof(val));
-}
-
-
-#if !(defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH))
-/* execvp is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED, so must be
- * avoided. Since this isn't called on those targets, the function
- * doesn't even need to be defined for them.
- */
-static void uv__process_child_init(const uv_process_options_t* options,
-                                   int stdio_count,
-                                   int (*pipes)[2],
-                                   int error_fd) {
-  sigset_t set;
-  int close_fd;
-  int use_fd;
-  int err;
-  int fd;
-  int n;
-
-  if (options->flags & UV_PROCESS_DETACHED)
-    setsid();
-
-  /* First duplicate low numbered fds, since it's not safe to duplicate them,
-   * they could get replaced. Example: swapping stdout and stderr; without
-   * this fd 2 (stderr) would be duplicated into fd 1, thus making both
-   * stdout and stderr go to the same fd, which was not the intention. */
-  for (fd = 0; fd < stdio_count; fd++) {
-    use_fd = pipes[fd][1];
-    if (use_fd < 0 || use_fd >= fd)
-      continue;
-    pipes[fd][1] = fcntl(use_fd, F_DUPFD, stdio_count);
-    if (pipes[fd][1] == -1) {
-      uv__write_int(error_fd, UV__ERR(errno));
-      _exit(127);
-    }
-  }
-
-  for (fd = 0; fd < stdio_count; fd++) {
-    close_fd = pipes[fd][0];
-    use_fd = pipes[fd][1];
-
-    if (use_fd < 0) {
-      if (fd >= 3)
-        continue;
-      else {
-        /* redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is
-         * set
-         */
-        use_fd = open("/dev/null", fd == 0 ? O_RDONLY : O_RDWR);
-        close_fd = use_fd;
-
-        if (use_fd < 0) {
-          uv__write_int(error_fd, UV__ERR(errno));
-          _exit(127);
-        }
-      }
-    }
-
-    if (fd == use_fd)
-      uv__cloexec_fcntl(use_fd, 0);
-    else
-      fd = dup2(use_fd, fd);
-
-    if (fd == -1) {
-      uv__write_int(error_fd, UV__ERR(errno));
-      _exit(127);
-    }
-
-    if (fd <= 2)
-      uv__nonblock_fcntl(fd, 0);
-
-    if (close_fd >= stdio_count)
-      uv__close(close_fd);
-  }
-
-  for (fd = 0; fd < stdio_count; fd++) {
-    use_fd = pipes[fd][1];
-
-    if (use_fd >= stdio_count)
-      uv__close(use_fd);
-  }
-
-  if (options->cwd != NULL && chdir(options->cwd)) {
-    uv__write_int(error_fd, UV__ERR(errno));
-    _exit(127);
-  }
-
-  if (options->flags & (UV_PROCESS_SETUID | UV_PROCESS_SETGID)) {
-    /* When dropping privileges from root, the `setgroups` call will
-     * remove any extraneous groups. If we don't call this, then
-     * even though our uid has dropped, we may still have groups
-     * that enable us to do super-user things. This will fail if we
-     * aren't root, so don't bother checking the return value, this
-     * is just done as an optimistic privilege dropping function.
-     */
-    SAVE_ERRNO(setgroups(0, NULL));
-  }
-
-  if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid)) {
-    uv__write_int(error_fd, UV__ERR(errno));
-    _exit(127);
-  }
-
-  if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid)) {
-    uv__write_int(error_fd, UV__ERR(errno));
-    _exit(127);
-  }
-
-  if (options->env != NULL) {
-    environ = options->env;
-  }
-
-  /* Reset signal disposition.  Use a hard-coded limit because NSIG
-   * is not fixed on Linux: it's either 32, 34 or 64, depending on
-   * whether RT signals are enabled.  We are not allowed to touch
-   * RT signal handlers, glibc uses them internally.
-   */
-  for (n = 1; n < 32; n += 1) {
-    if (n == SIGKILL || n == SIGSTOP)
-      continue;  /* Can't be changed. */
-
-#if defined(__HAIKU__)
-    if (n == SIGKILLTHR)
-      continue;  /* Can't be changed. */
-#endif
-
-    if (SIG_ERR != signal(n, SIG_DFL))
-      continue;
-
-    uv__write_int(error_fd, UV__ERR(errno));
-    _exit(127);
-  }
-
-  /* Reset signal mask. */
-  sigemptyset(&set);
-  err = pthread_sigmask(SIG_SETMASK, &set, NULL);
-
-  if (err != 0) {
-    uv__write_int(error_fd, UV__ERR(err));
-    _exit(127);
-  }
-
-  execvp(options->file, options->args);
-  uv__write_int(error_fd, UV__ERR(errno));
-  _exit(127);
-}
-#endif
-
-
-int uv_spawn(uv_loop_t* loop,
-             uv_process_t* process,
-             const uv_process_options_t* options) {
-#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
-  /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */
-  return UV_ENOSYS;
-#else
-  int signal_pipe[2] = { -1, -1 };
-  int pipes_storage[8][2];
-  int (*pipes)[2];
-  int stdio_count;
-  ssize_t r;
-  pid_t pid;
-  int err;
-  int exec_errorno;
-  int i;
-  int status;
-
-  assert(options->file != NULL);
-  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
-                              UV_PROCESS_SETGID |
-                              UV_PROCESS_SETUID |
-                              UV_PROCESS_WINDOWS_HIDE |
-                              UV_PROCESS_WINDOWS_HIDE_CONSOLE |
-                              UV_PROCESS_WINDOWS_HIDE_GUI |
-                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
-
-  uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
-  QUEUE_INIT(&process->queue);
-
-  stdio_count = options->stdio_count;
-  if (stdio_count < 3)
-    stdio_count = 3;
-
-  err = UV_ENOMEM;
-  pipes = pipes_storage;
-  if (stdio_count > (int) ARRAY_SIZE(pipes_storage))
-    pipes = (int (*)[2])uv__malloc(stdio_count * sizeof(*pipes));
-
-  if (pipes == NULL)
-    goto error;
-
-  for (i = 0; i < stdio_count; i++) {
-    pipes[i][0] = -1;
-    pipes[i][1] = -1;
-  }
-
-  for (i = 0; i < options->stdio_count; i++) {
-    err = uv__process_init_stdio(options->stdio + i, pipes[i]);
-    if (err)
-      goto error;
-  }
-
-  /* This pipe is used by the parent to wait until
-   * the child has called `execve()`. We need this
-   * to avoid the following race condition:
-   *
-   *    if ((pid = fork()) > 0) {
-   *      kill(pid, SIGTERM);
-   *    }
-   *    else if (pid == 0) {
-   *      execve("/bin/cat", argp, envp);
-   *    }
-   *
-   * The parent sends a signal immediately after forking.
-   * Since the child may not have called `execve()` yet,
-   * there is no telling what process receives the signal,
-   * our fork or /bin/cat.
-   *
-   * To avoid ambiguity, we create a pipe with both ends
-   * marked close-on-exec. Then, after the call to `fork()`,
-   * the parent polls the read end until it EOFs or errors with EPIPE.
-   */
-  err = uv__make_pipe(signal_pipe, 0);
-  if (err)
-    goto error;
-
-  uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD);
-
-  /* Acquire write lock to prevent opening new fds in worker threads */
-  uv_rwlock_wrlock(&loop->cloexec_lock);
-  pid = fork();
-
-  if (pid == -1) {
-    err = UV__ERR(errno);
-    uv_rwlock_wrunlock(&loop->cloexec_lock);
-    uv__close(signal_pipe[0]);
-    uv__close(signal_pipe[1]);
-    goto error;
-  }
-
-  if (pid == 0) {
-    uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]);
-    abort();
-  }
-
-  /* Release lock in parent process */
-  uv_rwlock_wrunlock(&loop->cloexec_lock);
-  uv__close(signal_pipe[1]);
-
-  process->status = 0;
-  exec_errorno = 0;
-  do
-    r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
-  while (r == -1 && errno == EINTR);
-
-  if (r == 0)
-    ; /* okay, EOF */
-  else if (r == sizeof(exec_errorno)) {
-    do
-      err = waitpid(pid, &status, 0); /* okay, read errorno */
-    while (err == -1 && errno == EINTR);
-    assert(err == pid);
-  } else if (r == -1 && errno == EPIPE) {
-    do
-      err = waitpid(pid, &status, 0); /* okay, got EPIPE */
-    while (err == -1 && errno == EINTR);
-    assert(err == pid);
-  } else
-    abort();
-
-  uv__close_nocheckstdio(signal_pipe[0]);
-
-  for (i = 0; i < options->stdio_count; i++) {
-    err = uv__process_open_stream(options->stdio + i, pipes[i]);
-    if (err == 0)
-      continue;
-
-    while (i--)
-      uv__process_close_stream(options->stdio + i);
-
-    goto error;
-  }
-
-  /* Only activate this handle if exec() happened successfully */
-  if (exec_errorno == 0) {
-    QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue);
-    uv__handle_start(process);
-  }
-
-  process->pid = pid;
-  process->exit_cb = options->exit_cb;
-
-  if (pipes != pipes_storage)
-    uv__free(pipes);
-
-  return exec_errorno;
-
-error:
-  if (pipes != NULL) {
-    for (i = 0; i < stdio_count; i++) {
-      if (i < options->stdio_count)
-        if (options->stdio[i].flags & (UV_INHERIT_FD | UV_INHERIT_STREAM))
-          continue;
-      if (pipes[i][0] != -1)
-        uv__close_nocheckstdio(pipes[i][0]);
-      if (pipes[i][1] != -1)
-        uv__close_nocheckstdio(pipes[i][1]);
-    }
-
-    if (pipes != pipes_storage)
-      uv__free(pipes);
-  }
-
-  return err;
-#endif
-}
-
-
-int uv_process_kill(uv_process_t* process, int signum) {
-  return uv_kill(process->pid, signum);
-}
-
-
-int uv_kill(int pid, int signum) {
-  if (kill(pid, signum))
-    return UV__ERR(errno);
-  else
-    return 0;
-}
-
-
-void uv__process_close(uv_process_t* handle) {
-  QUEUE_REMOVE(&handle->queue);
-  uv__handle_stop(handle);
-  if (QUEUE_EMPTY(&handle->loop->process_handles))
-    uv_signal_stop(&handle->loop->child_watcher);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/procfs-exepath.cpp b/wpiutil/src/main/native/libuv/src/unix/procfs-exepath.cpp
deleted file mode 100644
index 00dc021..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/procfs-exepath.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stddef.h>
-#include <unistd.h>
-
-int uv_exepath(char* buffer, size_t* size) {
-  ssize_t n;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  n = *size - 1;
-  if (n > 0)
-    n = readlink("/proc/self/exe", buffer, n);
-
-  if (n == -1)
-    return UV__ERR(errno);
-
-  buffer[n] = '\0';
-  *size = n;
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/proctitle.cpp b/wpiutil/src/main/native/libuv/src/unix/proctitle.cpp
deleted file mode 100644
index b09808f..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/proctitle.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-extern void uv__set_process_title_platform_init(void);
-extern void uv__set_process_title(const char* title);
-
-static uv_mutex_t process_title_mutex;
-static uv_once_t process_title_mutex_once = UV_ONCE_INIT;
-static void* args_mem;
-
-static struct {
-  char* str;
-  size_t len;
-} process_title;
-
-
-static void init_process_title_mutex_once(void) {
-  uv_mutex_init(&process_title_mutex);
-#ifdef __APPLE__
-  uv__set_process_title_platform_init();
-#endif
-}
-
-
-char** uv_setup_args(int argc, char** argv) {
-  char** new_argv;
-  size_t size;
-  char* s;
-  int i;
-
-  if (argc <= 0)
-    return argv;
-
-  /* Calculate how much memory we need for the argv strings. */
-  size = 0;
-  for (i = 0; i < argc; i++)
-    size += strlen(argv[i]) + 1;
-
-#if defined(__MVS__)
-  /* argv is not adjacent. So just use argv[0] */
-  process_title.str = argv[0];
-  process_title.len = strlen(argv[0]);
-#else
-  process_title.str = argv[0];
-  process_title.len = argv[argc - 1] + strlen(argv[argc - 1]) - argv[0];
-  assert(process_title.len + 1 == size);  /* argv memory should be adjacent. */
-#endif
-
-  /* Add space for the argv pointers. */
-  size += (argc + 1) * sizeof(char*);
-
-  new_argv = (char**)uv__malloc(size);
-  if (new_argv == NULL)
-    return argv;
-  args_mem = new_argv;
-
-  /* Copy over the strings and set up the pointer table. */
-  s = (char*) &new_argv[argc + 1];
-  for (i = 0; i < argc; i++) {
-    size = strlen(argv[i]) + 1;
-    memcpy(s, argv[i], size);
-    new_argv[i] = s;
-    s += size;
-  }
-  new_argv[i] = NULL;
-
-  return new_argv;
-}
-
-
-int uv_set_process_title(const char* title) {
-  uv_once(&process_title_mutex_once, init_process_title_mutex_once);
-  uv_mutex_lock(&process_title_mutex);
-
-  if (process_title.len != 0) {
-    /* No need to terminate, byte after is always '\0'. */
-    strncpy(process_title.str, title, process_title.len);
-    uv__set_process_title(title);
-  }
-
-  uv_mutex_unlock(&process_title_mutex);
-
-  return 0;
-}
-
-
-int uv_get_process_title(char* buffer, size_t size) {
-  if (buffer == NULL || size == 0)
-    return UV_EINVAL;
-
-  uv_once(&process_title_mutex_once, init_process_title_mutex_once);
-  uv_mutex_lock(&process_title_mutex);
-
-  if (size <= process_title.len) {
-    uv_mutex_unlock(&process_title_mutex);
-    return UV_ENOBUFS;
-  }
-
-  if (process_title.len != 0)
-    memcpy(buffer, process_title.str, process_title.len + 1);
-
-  buffer[process_title.len] = '\0';
-
-  uv_mutex_unlock(&process_title_mutex);
-
-  return 0;
-}
-
-
-UV_DESTRUCTOR(static void free_args_mem(void)) {
-  uv__free(args_mem);  /* Keep valgrind happy. */
-  args_mem = NULL;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/pthread-fixes.cpp b/wpiutil/src/main/native/libuv/src/unix/pthread-fixes.cpp
deleted file mode 100644
index fb17995..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/pthread-fixes.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Copyright (c) 2013, Sony Mobile Communications AB
- * Copyright (c) 2012, 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.
-*/
-
-/* Android versions < 4.1 have a broken pthread_sigmask. */
-#include <errno.h>
-#include <pthread.h>
-#include <signal.h>
-
-int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset) {
-  static int workaround;
-  int err;
-
-  if (workaround) {
-    return sigprocmask(how, set, oset);
-  } else {
-    err = pthread_sigmask(how, set, oset);
-    if (err) {
-      if (err == EINVAL && sigprocmask(how, set, oset) == 0) {
-        workaround = 1;
-        return 0;
-      } else {
-        return -1;
-      }
-    }
-  }
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/signal.cpp b/wpiutil/src/main/native/libuv/src/unix/signal.cpp
deleted file mode 100644
index ec2639a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/signal.cpp
+++ /dev/null
@@ -1,574 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <errno.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#ifndef SA_RESTART
-# define SA_RESTART 0
-#endif
-
-typedef struct {
-  uv_signal_t* handle;
-  int signum;
-} uv__signal_msg_t;
-
-RB_HEAD(uv__signal_tree_s, uv_signal_s);
-
-
-static int uv__signal_unlock(void);
-static int uv__signal_start(uv_signal_t* handle,
-                            uv_signal_cb signal_cb,
-                            int signum,
-                            int oneshot);
-static void uv__signal_event(uv_loop_t* loop, uv__io_t* w, unsigned int events);
-static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2);
-static void uv__signal_stop(uv_signal_t* handle);
-static void uv__signal_unregister_handler(int signum);
-
-
-static uv_once_t uv__signal_global_init_guard = UV_ONCE_INIT;
-static struct uv__signal_tree_s uv__signal_tree =
-    RB_INITIALIZER(uv__signal_tree);
-static int uv__signal_lock_pipefd[2] = { -1, -1 };
-
-RB_GENERATE_STATIC(uv__signal_tree_s,
-                   uv_signal_s, tree_entry,
-                   uv__signal_compare)
-
-static void uv__signal_global_reinit(void);
-
-static void uv__signal_global_init(void) {
-  if (uv__signal_lock_pipefd[0] == -1)
-    /* pthread_atfork can register before and after handlers, one
-     * for each child. This only registers one for the child. That
-     * state is both persistent and cumulative, so if we keep doing
-     * it the handler functions will be called multiple times. Thus
-     * we only want to do it once.
-     */
-    if (pthread_atfork(NULL, NULL, &uv__signal_global_reinit))
-      abort();
-
-  uv__signal_global_reinit();
-}
-
-
-UV_DESTRUCTOR(static void uv__signal_global_fini(void)) {
-  /* We can only use signal-safe functions here.
-   * That includes read/write and close, fortunately.
-   * We do all of this directly here instead of resetting
-   * uv__signal_global_init_guard because
-   * uv__signal_global_once_init is only called from uv_loop_init
-   * and this needs to function in existing loops.
-   */
-  if (uv__signal_lock_pipefd[0] != -1) {
-    uv__close(uv__signal_lock_pipefd[0]);
-    uv__signal_lock_pipefd[0] = -1;
-  }
-
-  if (uv__signal_lock_pipefd[1] != -1) {
-    uv__close(uv__signal_lock_pipefd[1]);
-    uv__signal_lock_pipefd[1] = -1;
-  }
-}
-
-
-static void uv__signal_global_reinit(void) {
-  uv__signal_global_fini();
-
-  if (uv__make_pipe(uv__signal_lock_pipefd, 0))
-    abort();
-
-  if (uv__signal_unlock())
-    abort();
-}
-
-
-void uv__signal_global_once_init(void) {
-  uv_once(&uv__signal_global_init_guard, uv__signal_global_init);
-}
-
-
-static int uv__signal_lock(void) {
-  int r;
-  char data;
-
-  do {
-    r = read(uv__signal_lock_pipefd[0], &data, sizeof data);
-  } while (r < 0 && errno == EINTR);
-
-  return (r < 0) ? -1 : 0;
-}
-
-
-static int uv__signal_unlock(void) {
-  int r;
-  char data = 42;
-
-  do {
-    r = write(uv__signal_lock_pipefd[1], &data, sizeof data);
-  } while (r < 0 && errno == EINTR);
-
-  return (r < 0) ? -1 : 0;
-}
-
-
-static void uv__signal_block_and_lock(sigset_t* saved_sigmask) {
-  sigset_t new_mask;
-
-  if (sigfillset(&new_mask))
-    abort();
-
-  if (pthread_sigmask(SIG_SETMASK, &new_mask, saved_sigmask))
-    abort();
-
-  if (uv__signal_lock())
-    abort();
-}
-
-
-static void uv__signal_unlock_and_unblock(sigset_t* saved_sigmask) {
-  if (uv__signal_unlock())
-    abort();
-
-  if (pthread_sigmask(SIG_SETMASK, saved_sigmask, NULL))
-    abort();
-}
-
-
-static uv_signal_t* uv__signal_first_handle(int signum) {
-  /* This function must be called with the signal lock held. */
-  uv_signal_t lookup;
-  uv_signal_t* handle;
-
-  lookup.signum = signum;
-  lookup.flags = 0;
-  lookup.loop = NULL;
-
-  handle = RB_NFIND(uv__signal_tree_s, &uv__signal_tree, &lookup);
-
-  if (handle != NULL && handle->signum == signum)
-    return handle;
-
-  return NULL;
-}
-
-
-static void uv__signal_handler(int signum) {
-  uv__signal_msg_t msg;
-  uv_signal_t* handle;
-  int saved_errno;
-
-  saved_errno = errno;
-  memset(&msg, 0, sizeof msg);
-
-  if (uv__signal_lock()) {
-    errno = saved_errno;
-    return;
-  }
-
-  for (handle = uv__signal_first_handle(signum);
-       handle != NULL && handle->signum == signum;
-       handle = RB_NEXT(uv__signal_tree_s, &uv__signal_tree, handle)) {
-    int r;
-
-    msg.signum = signum;
-    msg.handle = handle;
-
-    /* write() should be atomic for small data chunks, so the entire message
-     * should be written at once. In theory the pipe could become full, in
-     * which case the user is out of luck.
-     */
-    do {
-      r = write(handle->loop->signal_pipefd[1], &msg, sizeof msg);
-    } while (r == -1 && errno == EINTR);
-
-    assert(r == sizeof msg ||
-           (r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)));
-
-    if (r != -1)
-      handle->caught_signals++;
-  }
-
-  uv__signal_unlock();
-  errno = saved_errno;
-}
-
-
-static int uv__signal_register_handler(int signum, int oneshot) {
-  /* When this function is called, the signal lock must be held. */
-  struct sigaction sa;
-
-  /* XXX use a separate signal stack? */
-  memset(&sa, 0, sizeof(sa));
-  if (sigfillset(&sa.sa_mask))
-    abort();
-  sa.sa_handler = uv__signal_handler;
-  sa.sa_flags = SA_RESTART;
-  if (oneshot)
-    sa.sa_flags |= SA_RESETHAND;
-
-  /* XXX save old action so we can restore it later on? */
-  if (sigaction(signum, &sa, NULL))
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-
-static void uv__signal_unregister_handler(int signum) {
-  /* When this function is called, the signal lock must be held. */
-  struct sigaction sa;
-
-  memset(&sa, 0, sizeof(sa));
-  sa.sa_handler = SIG_DFL;
-
-  /* sigaction can only fail with EINVAL or EFAULT; an attempt to deregister a
-   * signal implies that it was successfully registered earlier, so EINVAL
-   * should never happen.
-   */
-  if (sigaction(signum, &sa, NULL))
-    abort();
-}
-
-
-static int uv__signal_loop_once_init(uv_loop_t* loop) {
-  int err;
-
-  /* Return if already initialized. */
-  if (loop->signal_pipefd[0] != -1)
-    return 0;
-
-  err = uv__make_pipe(loop->signal_pipefd, UV__F_NONBLOCK);
-  if (err)
-    return err;
-
-  uv__io_init(&loop->signal_io_watcher,
-              uv__signal_event,
-              loop->signal_pipefd[0]);
-  uv__io_start(loop, &loop->signal_io_watcher, POLLIN);
-
-  return 0;
-}
-
-
-int uv__signal_loop_fork(uv_loop_t* loop) {
-  uv__io_stop(loop, &loop->signal_io_watcher, POLLIN);
-  uv__close(loop->signal_pipefd[0]);
-  uv__close(loop->signal_pipefd[1]);
-  loop->signal_pipefd[0] = -1;
-  loop->signal_pipefd[1] = -1;
-  return uv__signal_loop_once_init(loop);
-}
-
-
-void uv__signal_loop_cleanup(uv_loop_t* loop) {
-  QUEUE* q;
-
-  /* Stop all the signal watchers that are still attached to this loop. This
-   * ensures that the (shared) signal tree doesn't contain any invalid entries
-   * entries, and that signal handlers are removed when appropriate.
-   * It's safe to use QUEUE_FOREACH here because the handles and the handle
-   * queue are not modified by uv__signal_stop().
-   */
-  QUEUE_FOREACH(q, &loop->handle_queue) {
-    uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue);
-
-    if (handle->type == UV_SIGNAL)
-      uv__signal_stop((uv_signal_t*) handle);
-  }
-
-  if (loop->signal_pipefd[0] != -1) {
-    uv__close(loop->signal_pipefd[0]);
-    loop->signal_pipefd[0] = -1;
-  }
-
-  if (loop->signal_pipefd[1] != -1) {
-    uv__close(loop->signal_pipefd[1]);
-    loop->signal_pipefd[1] = -1;
-  }
-}
-
-
-int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) {
-  int err;
-
-  err = uv__signal_loop_once_init(loop);
-  if (err)
-    return err;
-
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
-  handle->signum = 0;
-  handle->caught_signals = 0;
-  handle->dispatched_signals = 0;
-
-  return 0;
-}
-
-
-void uv__signal_close(uv_signal_t* handle) {
-
-  uv__signal_stop(handle);
-
-  /* If there are any caught signals "trapped" in the signal pipe, we can't
-   * call the close callback yet. Otherwise, add the handle to the finish_close
-   * queue.
-   */
-  if (handle->caught_signals == handle->dispatched_signals) {
-    uv__make_close_pending((uv_handle_t*) handle);
-  }
-}
-
-
-int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) {
-  return uv__signal_start(handle, signal_cb, signum, 0);
-}
-
-
-int uv_signal_start_oneshot(uv_signal_t* handle,
-                            uv_signal_cb signal_cb,
-                            int signum) {
-  return uv__signal_start(handle, signal_cb, signum, 1);
-}
-
-
-static int uv__signal_start(uv_signal_t* handle,
-                            uv_signal_cb signal_cb,
-                            int signum,
-                            int oneshot) {
-  sigset_t saved_sigmask;
-  int err;
-  uv_signal_t* first_handle;
-
-  assert(!uv__is_closing(handle));
-
-  /* If the user supplies signum == 0, then return an error already. If the
-   * signum is otherwise invalid then uv__signal_register will find out
-   * eventually.
-   */
-  if (signum == 0)
-    return UV_EINVAL;
-
-  /* Short circuit: if the signal watcher is already watching {signum} don't
-   * go through the process of deregistering and registering the handler.
-   * Additionally, this avoids pending signals getting lost in the small
-   * time frame that handle->signum == 0.
-   */
-  if (signum == handle->signum) {
-    handle->signal_cb = signal_cb;
-    return 0;
-  }
-
-  /* If the signal handler was already active, stop it first. */
-  if (handle->signum != 0) {
-    uv__signal_stop(handle);
-  }
-
-  uv__signal_block_and_lock(&saved_sigmask);
-
-  /* If at this point there are no active signal watchers for this signum (in
-   * any of the loops), it's time to try and register a handler for it here.
-   * Also in case there's only one-shot handlers and a regular handler comes in.
-   */
-  first_handle = uv__signal_first_handle(signum);
-  if (first_handle == NULL ||
-      (!oneshot && (first_handle->flags & UV_SIGNAL_ONE_SHOT))) {
-    err = uv__signal_register_handler(signum, oneshot);
-    if (err) {
-      /* Registering the signal handler failed. Must be an invalid signal. */
-      uv__signal_unlock_and_unblock(&saved_sigmask);
-      return err;
-    }
-  }
-
-  handle->signum = signum;
-  if (oneshot)
-    handle->flags |= UV_SIGNAL_ONE_SHOT;
-
-  RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle);
-
-  uv__signal_unlock_and_unblock(&saved_sigmask);
-
-  handle->signal_cb = signal_cb;
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-static void uv__signal_event(uv_loop_t* loop,
-                             uv__io_t* w,
-                             unsigned int events) {
-  uv__signal_msg_t* msg;
-  uv_signal_t* handle;
-  char buf[sizeof(uv__signal_msg_t) * 32];
-  size_t bytes, end, i;
-  int r;
-
-  bytes = 0;
-  end = 0;
-
-  do {
-    r = read(loop->signal_pipefd[0], buf + bytes, sizeof(buf) - bytes);
-
-    if (r == -1 && errno == EINTR)
-      continue;
-
-    if (r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-      /* If there are bytes in the buffer already (which really is extremely
-       * unlikely if possible at all) we can't exit the function here. We'll
-       * spin until more bytes are read instead.
-       */
-      if (bytes > 0)
-        continue;
-
-      /* Otherwise, there was nothing there. */
-      return;
-    }
-
-    /* Other errors really should never happen. */
-    if (r == -1)
-      abort();
-
-    bytes += r;
-
-    /* `end` is rounded down to a multiple of sizeof(uv__signal_msg_t). */
-    end = (bytes / sizeof(uv__signal_msg_t)) * sizeof(uv__signal_msg_t);
-
-    for (i = 0; i < end; i += sizeof(uv__signal_msg_t)) {
-      msg = (uv__signal_msg_t*) (buf + i);
-      handle = msg->handle;
-
-      if (msg->signum == handle->signum) {
-        assert(!(handle->flags & UV_HANDLE_CLOSING));
-        handle->signal_cb(handle, handle->signum);
-      }
-
-      handle->dispatched_signals++;
-
-      if (handle->flags & UV_SIGNAL_ONE_SHOT)
-        uv__signal_stop(handle);
-
-      /* If uv_close was called while there were caught signals that were not
-       * yet dispatched, the uv__finish_close was deferred. Make close pending
-       * now if this has happened.
-       */
-      if ((handle->flags & UV_HANDLE_CLOSING) &&
-          (handle->caught_signals == handle->dispatched_signals)) {
-        uv__make_close_pending((uv_handle_t*) handle);
-      }
-    }
-
-    bytes -= end;
-
-    /* If there are any "partial" messages left, move them to the start of the
-     * the buffer, and spin. This should not happen.
-     */
-    if (bytes) {
-      memmove(buf, buf + end, bytes);
-      continue;
-    }
-  } while (end == sizeof buf);
-}
-
-
-static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
-  int f1;
-  int f2;
-  /* Compare signums first so all watchers with the same signnum end up
-   * adjacent.
-   */
-  if (w1->signum < w2->signum) return -1;
-  if (w1->signum > w2->signum) return 1;
-
-  /* Handlers without UV_SIGNAL_ONE_SHOT set will come first, so if the first
-   * handler returned is a one-shot handler, the rest will be too.
-   */
-  f1 = w1->flags & UV_SIGNAL_ONE_SHOT;
-  f2 = w2->flags & UV_SIGNAL_ONE_SHOT;
-  if (f1 < f2) return -1;
-  if (f1 > f2) return 1;
-
-  /* Sort by loop pointer, so we can easily look up the first item after
-   * { .signum = x, .loop = NULL }.
-   */
-  if (w1->loop < w2->loop) return -1;
-  if (w1->loop > w2->loop) return 1;
-
-  if (w1 < w2) return -1;
-  if (w1 > w2) return 1;
-
-  return 0;
-}
-
-
-int uv_signal_stop(uv_signal_t* handle) {
-  assert(!uv__is_closing(handle));
-  uv__signal_stop(handle);
-  return 0;
-}
-
-
-static void uv__signal_stop(uv_signal_t* handle) {
-  uv_signal_t* removed_handle;
-  sigset_t saved_sigmask;
-  uv_signal_t* first_handle;
-  int rem_oneshot;
-  int first_oneshot;
-  int ret;
-
-  /* If the watcher wasn't started, this is a no-op. */
-  if (handle->signum == 0)
-    return;
-
-  uv__signal_block_and_lock(&saved_sigmask);
-
-  removed_handle = RB_REMOVE(uv__signal_tree_s, &uv__signal_tree, handle);
-  assert(removed_handle == handle);
-  (void) removed_handle;
-
-  /* Check if there are other active signal watchers observing this signal. If
-   * not, unregister the signal handler.
-   */
-  first_handle = uv__signal_first_handle(handle->signum);
-  if (first_handle == NULL) {
-    uv__signal_unregister_handler(handle->signum);
-  } else {
-    rem_oneshot = handle->flags & UV_SIGNAL_ONE_SHOT;
-    first_oneshot = first_handle->flags & UV_SIGNAL_ONE_SHOT;
-    if (first_oneshot && !rem_oneshot) {
-      ret = uv__signal_register_handler(handle->signum, 1);
-      assert(ret == 0);
-      (void) ret;
-    }
-  }
-
-  uv__signal_unlock_and_unblock(&saved_sigmask);
-
-  handle->signum = 0;
-  uv__handle_stop(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/spinlock.h b/wpiutil/src/main/native/libuv/src/unix/spinlock.h
deleted file mode 100644
index a20c83c..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/spinlock.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef UV_SPINLOCK_H_
-#define UV_SPINLOCK_H_
-
-#include "internal.h"  /* ACCESS_ONCE, UV_UNUSED */
-#include "atomic-ops.h"
-
-#define UV_SPINLOCK_INITIALIZER { 0 }
-
-typedef struct {
-  int lock;
-} uv_spinlock_t;
-
-UV_UNUSED(static void uv_spinlock_init(uv_spinlock_t* spinlock));
-UV_UNUSED(static void uv_spinlock_lock(uv_spinlock_t* spinlock));
-UV_UNUSED(static void uv_spinlock_unlock(uv_spinlock_t* spinlock));
-UV_UNUSED(static int uv_spinlock_trylock(uv_spinlock_t* spinlock));
-
-UV_UNUSED(static void uv_spinlock_init(uv_spinlock_t* spinlock)) {
-  ACCESS_ONCE(int, spinlock->lock) = 0;
-}
-
-UV_UNUSED(static void uv_spinlock_lock(uv_spinlock_t* spinlock)) {
-  while (!uv_spinlock_trylock(spinlock)) cpu_relax();
-}
-
-UV_UNUSED(static void uv_spinlock_unlock(uv_spinlock_t* spinlock)) {
-  ACCESS_ONCE(int, spinlock->lock) = 0;
-}
-
-UV_UNUSED(static int uv_spinlock_trylock(uv_spinlock_t* spinlock)) {
-  /* TODO(bnoordhuis) Maybe change to a ticket lock to guarantee fair queueing.
-   * Not really critical until we have locks that are (frequently) contended
-   * for by several threads.
-   */
-  return 0 == cmpxchgi(&spinlock->lock, 0, 1);
-}
-
-#endif  /* UV_SPINLOCK_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/unix/stream.cpp b/wpiutil/src/main/native/libuv/src/unix/stream.cpp
deleted file mode 100644
index f3a8e66..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/stream.cpp
+++ /dev/null
@@ -1,1689 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <unistd.h>
-#include <limits.h> /* IOV_MAX */
-
-#if defined(__APPLE__)
-# include <sys/event.h>
-# include <sys/time.h>
-# include <sys/select.h>
-
-/* Forward declaration */
-typedef struct uv__stream_select_s uv__stream_select_t;
-
-struct uv__stream_select_s {
-  uv_stream_t* stream;
-  uv_thread_t thread;
-  uv_sem_t close_sem;
-  uv_sem_t async_sem;
-  uv_async_t async;
-  int events;
-  int fake_fd;
-  int int_fd;
-  int fd;
-  fd_set* sread;
-  size_t sread_sz;
-  fd_set* swrite;
-  size_t swrite_sz;
-};
-
-/* Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
- * EPROTOTYPE can be returned while trying to write to a socket that is
- * shutting down. If we retry the write, we should get the expected EPIPE
- * instead.
- */
-# define RETRY_ON_WRITE_ERROR(errno) (errno == EINTR || errno == EPROTOTYPE)
-# define IS_TRANSIENT_WRITE_ERROR(errno, send_handle) \
-    (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS || \
-     (errno == EMSGSIZE && send_handle != NULL))
-#else
-# define RETRY_ON_WRITE_ERROR(errno) (errno == EINTR)
-# define IS_TRANSIENT_WRITE_ERROR(errno, send_handle) \
-    (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
-#endif /* defined(__APPLE__) */
-
-static void uv__stream_connect(uv_stream_t*);
-static void uv__write(uv_stream_t* stream);
-static void uv__read(uv_stream_t* stream);
-static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events);
-static void uv__write_callbacks(uv_stream_t* stream);
-static size_t uv__write_req_size(uv_write_t* req);
-
-
-void uv__stream_init(uv_loop_t* loop,
-                     uv_stream_t* stream,
-                     uv_handle_type type) {
-  int err;
-
-  uv__handle_init(loop, (uv_handle_t*)stream, type);
-  stream->read_cb = NULL;
-  stream->alloc_cb = NULL;
-  stream->close_cb = NULL;
-  stream->connection_cb = NULL;
-  stream->connect_req = NULL;
-  stream->shutdown_req = NULL;
-  stream->accepted_fd = -1;
-  stream->queued_fds = NULL;
-  stream->delayed_error = 0;
-  QUEUE_INIT(&stream->write_queue);
-  QUEUE_INIT(&stream->write_completed_queue);
-  stream->write_queue_size = 0;
-
-  if (loop->emfile_fd == -1) {
-    err = uv__open_cloexec("/dev/null", O_RDONLY);
-    if (err < 0)
-        /* In the rare case that "/dev/null" isn't mounted open "/"
-         * instead.
-         */
-        err = uv__open_cloexec("/", O_RDONLY);
-    if (err >= 0)
-      loop->emfile_fd = err;
-  }
-
-#if defined(__APPLE__)
-  stream->select = NULL;
-#endif /* defined(__APPLE_) */
-
-  uv__io_init(&stream->io_watcher, uv__stream_io, -1);
-}
-
-
-static void uv__stream_osx_interrupt_select(uv_stream_t* stream) {
-#if defined(__APPLE__)
-  /* Notify select() thread about state change */
-  uv__stream_select_t* s;
-  int r;
-
-  s = (uv__stream_select_t*)stream->select;
-  if (s == NULL)
-    return;
-
-  /* Interrupt select() loop
-   * NOTE: fake_fd and int_fd are socketpair(), thus writing to one will
-   * emit read event on other side
-   */
-  do
-    r = write(s->fake_fd, "x", 1);
-  while (r == -1 && errno == EINTR);
-
-  assert(r == 1);
-#else  /* !defined(__APPLE__) */
-  /* No-op on any other platform */
-#endif  /* !defined(__APPLE__) */
-}
-
-
-#if defined(__APPLE__)
-static void uv__stream_osx_select(void* arg) {
-  uv_stream_t* stream;
-  uv__stream_select_t* s;
-  char buf[1024];
-  int events;
-  int fd;
-  int r;
-  int max_fd;
-
-  stream = (uv_stream_t*)arg;
-  s = (uv__stream_select_t*)stream->select;
-  fd = s->fd;
-
-  if (fd > s->int_fd)
-    max_fd = fd;
-  else
-    max_fd = s->int_fd;
-
-  while (1) {
-    /* Terminate on semaphore */
-    if (uv_sem_trywait(&s->close_sem) == 0)
-      break;
-
-    /* Watch fd using select(2) */
-    memset(s->sread, 0, s->sread_sz);
-    memset(s->swrite, 0, s->swrite_sz);
-
-    if (uv__io_active(&stream->io_watcher, POLLIN))
-      FD_SET(fd, s->sread);
-    if (uv__io_active(&stream->io_watcher, POLLOUT))
-      FD_SET(fd, s->swrite);
-    FD_SET(s->int_fd, s->sread);
-
-    /* Wait indefinitely for fd events */
-    r = select(max_fd + 1, s->sread, s->swrite, NULL, NULL);
-    if (r == -1) {
-      if (errno == EINTR)
-        continue;
-
-      /* XXX: Possible?! */
-      abort();
-    }
-
-    /* Ignore timeouts */
-    if (r == 0)
-      continue;
-
-    /* Empty socketpair's buffer in case of interruption */
-    if (FD_ISSET(s->int_fd, s->sread))
-      while (1) {
-        r = read(s->int_fd, buf, sizeof(buf));
-
-        if (r == sizeof(buf))
-          continue;
-
-        if (r != -1)
-          break;
-
-        if (errno == EAGAIN || errno == EWOULDBLOCK)
-          break;
-
-        if (errno == EINTR)
-          continue;
-
-        abort();
-      }
-
-    /* Handle events */
-    events = 0;
-    if (FD_ISSET(fd, s->sread))
-      events |= POLLIN;
-    if (FD_ISSET(fd, s->swrite))
-      events |= POLLOUT;
-
-    assert(events != 0 || FD_ISSET(s->int_fd, s->sread));
-    if (events != 0) {
-      ACCESS_ONCE(int, s->events) = events;
-
-      uv_async_send(&s->async);
-      uv_sem_wait(&s->async_sem);
-
-      /* Should be processed at this stage */
-      assert((s->events == 0) || (stream->flags & UV_HANDLE_CLOSING));
-    }
-  }
-}
-
-
-static void uv__stream_osx_select_cb(uv_async_t* handle) {
-  uv__stream_select_t* s;
-  uv_stream_t* stream;
-  int events;
-
-  s = container_of(handle, uv__stream_select_t, async);
-  stream = s->stream;
-
-  /* Get and reset stream's events */
-  events = s->events;
-  ACCESS_ONCE(int, s->events) = 0;
-
-  assert(events != 0);
-  assert(events == (events & (POLLIN | POLLOUT)));
-
-  /* Invoke callback on event-loop */
-  if ((events & POLLIN) && uv__io_active(&stream->io_watcher, POLLIN))
-    uv__stream_io(stream->loop, &stream->io_watcher, POLLIN);
-
-  if ((events & POLLOUT) && uv__io_active(&stream->io_watcher, POLLOUT))
-    uv__stream_io(stream->loop, &stream->io_watcher, POLLOUT);
-
-  if (stream->flags & UV_HANDLE_CLOSING)
-    return;
-
-  /* NOTE: It is important to do it here, otherwise `select()` might be called
-   * before the actual `uv__read()`, leading to the blocking syscall
-   */
-  uv_sem_post(&s->async_sem);
-}
-
-
-static void uv__stream_osx_cb_close(uv_handle_t* async) {
-  uv__stream_select_t* s;
-
-  s = container_of(async, uv__stream_select_t, async);
-  uv__free(s);
-}
-
-
-int uv__stream_try_select(uv_stream_t* stream, int* fd) {
-  /*
-   * kqueue doesn't work with some files from /dev mount on osx.
-   * select(2) in separate thread for those fds
-   */
-
-  struct kevent filter[1];
-  struct kevent events[1];
-  struct timespec timeout;
-  uv__stream_select_t* s;
-  int fds[2];
-  int err;
-  int ret;
-  int kq;
-  int old_fd;
-  int max_fd;
-  size_t sread_sz;
-  size_t swrite_sz;
-
-  kq = kqueue();
-  if (kq == -1) {
-    perror("(libuv) kqueue()");
-    return UV__ERR(errno);
-  }
-
-  EV_SET(&filter[0], *fd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, 0);
-
-  /* Use small timeout, because we only want to capture EINVALs */
-  timeout.tv_sec = 0;
-  timeout.tv_nsec = 1;
-
-  do
-    ret = kevent(kq, filter, 1, events, 1, &timeout);
-  while (ret == -1 && errno == EINTR);
-
-  uv__close(kq);
-
-  if (ret == -1)
-    return UV__ERR(errno);
-
-  if (ret == 0 || (events[0].flags & EV_ERROR) == 0 || events[0].data != EINVAL)
-    return 0;
-
-  /* At this point we definitely know that this fd won't work with kqueue */
-
-  /*
-   * Create fds for io watcher and to interrupt the select() loop.
-   * NOTE: do it ahead of malloc below to allocate enough space for fd_sets
-   */
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
-    return UV__ERR(errno);
-
-  max_fd = *fd;
-  if (fds[1] > max_fd)
-    max_fd = fds[1];
-
-  sread_sz = ROUND_UP(max_fd + 1, sizeof(uint32_t) * NBBY) / NBBY;
-  swrite_sz = sread_sz;
-
-  s = (uv__stream_select_t*)uv__malloc(sizeof(*s) + sread_sz + swrite_sz);
-  if (s == NULL) {
-    err = UV_ENOMEM;
-    goto failed_malloc;
-  }
-
-  s->events = 0;
-  s->fd = *fd;
-  s->sread = (fd_set*) ((char*) s + sizeof(*s));
-  s->sread_sz = sread_sz;
-  s->swrite = (fd_set*) ((char*) s->sread + sread_sz);
-  s->swrite_sz = swrite_sz;
-
-  err = uv_async_init(stream->loop, &s->async, uv__stream_osx_select_cb);
-  if (err)
-    goto failed_async_init;
-
-  s->async.flags |= UV_HANDLE_INTERNAL;
-  uv__handle_unref(&s->async);
-
-  err = uv_sem_init(&s->close_sem, 0);
-  if (err != 0)
-    goto failed_close_sem_init;
-
-  err = uv_sem_init(&s->async_sem, 0);
-  if (err != 0)
-    goto failed_async_sem_init;
-
-  s->fake_fd = fds[0];
-  s->int_fd = fds[1];
-
-  old_fd = *fd;
-  s->stream = stream;
-  stream->select = s;
-  *fd = s->fake_fd;
-
-  err = uv_thread_create(&s->thread, uv__stream_osx_select, stream);
-  if (err != 0)
-    goto failed_thread_create;
-
-  return 0;
-
-failed_thread_create:
-  s->stream = NULL;
-  stream->select = NULL;
-  *fd = old_fd;
-
-  uv_sem_destroy(&s->async_sem);
-
-failed_async_sem_init:
-  uv_sem_destroy(&s->close_sem);
-
-failed_close_sem_init:
-  uv__close(fds[0]);
-  uv__close(fds[1]);
-  uv_close((uv_handle_t*) &s->async, uv__stream_osx_cb_close);
-  return err;
-
-failed_async_init:
-  uv__free(s);
-
-failed_malloc:
-  uv__close(fds[0]);
-  uv__close(fds[1]);
-
-  return err;
-}
-#endif /* defined(__APPLE__) */
-
-
-int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
-#if defined(__APPLE__)
-  int enable;
-#endif
-
-  if (!(stream->io_watcher.fd == -1 || stream->io_watcher.fd == fd))
-    return UV_EBUSY;
-
-  assert(fd >= 0);
-  stream->flags |= flags;
-
-  if (stream->type == UV_TCP) {
-    if ((stream->flags & UV_HANDLE_TCP_NODELAY) && uv__tcp_nodelay(fd, 1))
-      return UV__ERR(errno);
-
-    /* TODO Use delay the user passed in. */
-    if ((stream->flags & UV_HANDLE_TCP_KEEPALIVE) &&
-        uv__tcp_keepalive(fd, 1, 60)) {
-      return UV__ERR(errno);
-    }
-  }
-
-#if defined(__APPLE__)
-  enable = 1;
-  if (setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &enable, sizeof(enable)) &&
-      errno != ENOTSOCK &&
-      errno != EINVAL) {
-    return UV__ERR(errno);
-  }
-#endif
-
-  stream->io_watcher.fd = fd;
-
-  return 0;
-}
-
-
-void uv__stream_flush_write_queue(uv_stream_t* stream, int error) {
-  uv_write_t* req;
-  QUEUE* q;
-  while (!QUEUE_EMPTY(&stream->write_queue)) {
-    q = QUEUE_HEAD(&stream->write_queue);
-    QUEUE_REMOVE(q);
-
-    req = QUEUE_DATA(q, uv_write_t, queue);
-    req->error = error;
-
-    QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue);
-  }
-}
-
-
-void uv__stream_destroy(uv_stream_t* stream) {
-  assert(!uv__io_active(&stream->io_watcher, POLLIN | POLLOUT));
-  assert(stream->flags & UV_HANDLE_CLOSED);
-
-  if (stream->connect_req) {
-    uv__req_unregister(stream->loop, stream->connect_req);
-    stream->connect_req->cb(stream->connect_req, UV_ECANCELED);
-    stream->connect_req = NULL;
-  }
-
-  uv__stream_flush_write_queue(stream, UV_ECANCELED);
-  uv__write_callbacks(stream);
-
-  if (stream->shutdown_req) {
-    /* The ECANCELED error code is a lie, the shutdown(2) syscall is a
-     * fait accompli at this point. Maybe we should revisit this in v0.11.
-     * A possible reason for leaving it unchanged is that it informs the
-     * callee that the handle has been destroyed.
-     */
-    uv__req_unregister(stream->loop, stream->shutdown_req);
-    stream->shutdown_req->cb(stream->shutdown_req, UV_ECANCELED);
-    stream->shutdown_req = NULL;
-  }
-
-  assert(stream->write_queue_size == 0);
-}
-
-
-/* Implements a best effort approach to mitigating accept() EMFILE errors.
- * We have a spare file descriptor stashed away that we close to get below
- * the EMFILE limit. Next, we accept all pending connections and close them
- * immediately to signal the clients that we're overloaded - and we are, but
- * we still keep on trucking.
- *
- * There is one caveat: it's not reliable in a multi-threaded environment.
- * The file descriptor limit is per process. Our party trick fails if another
- * thread opens a file or creates a socket in the time window between us
- * calling close() and accept().
- */
-static int uv__emfile_trick(uv_loop_t* loop, int accept_fd) {
-  int err;
-  int emfile_fd;
-
-  if (loop->emfile_fd == -1)
-    return UV_EMFILE;
-
-  uv__close(loop->emfile_fd);
-  loop->emfile_fd = -1;
-
-  do {
-    err = uv__accept(accept_fd);
-    if (err >= 0)
-      uv__close(err);
-  } while (err >= 0 || err == UV_EINTR);
-
-  emfile_fd = uv__open_cloexec("/", O_RDONLY);
-  if (emfile_fd >= 0)
-    loop->emfile_fd = emfile_fd;
-
-  return err;
-}
-
-
-#if defined(UV_HAVE_KQUEUE)
-# define UV_DEC_BACKLOG(w) w->rcount--;
-#else
-# define UV_DEC_BACKLOG(w) /* no-op */
-#endif /* defined(UV_HAVE_KQUEUE) */
-
-
-void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  uv_stream_t* stream;
-  int err;
-
-  stream = container_of(w, uv_stream_t, io_watcher);
-  assert(events & POLLIN);
-  assert(stream->accepted_fd == -1);
-  assert(!(stream->flags & UV_HANDLE_CLOSING));
-
-  uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
-
-  /* connection_cb can close the server socket while we're
-   * in the loop so check it on each iteration.
-   */
-  while (uv__stream_fd(stream) != -1) {
-    assert(stream->accepted_fd == -1);
-
-#if defined(UV_HAVE_KQUEUE)
-    if (w->rcount <= 0)
-      return;
-#endif /* defined(UV_HAVE_KQUEUE) */
-
-    err = uv__accept(uv__stream_fd(stream));
-    if (err < 0) {
-      if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK))
-        return;  /* Not an error. */
-
-      if (err == UV_ECONNABORTED)
-        continue;  /* Ignore. Nothing we can do about that. */
-
-      if (err == UV_EMFILE || err == UV_ENFILE) {
-        err = uv__emfile_trick(loop, uv__stream_fd(stream));
-        if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK))
-          break;
-      }
-
-      stream->connection_cb(stream, err);
-      continue;
-    }
-
-    UV_DEC_BACKLOG(w)
-    stream->accepted_fd = err;
-    stream->connection_cb(stream, 0);
-
-    if (stream->accepted_fd != -1) {
-      /* The user hasn't yet accepted called uv_accept() */
-      uv__io_stop(loop, &stream->io_watcher, POLLIN);
-      return;
-    }
-
-    if (stream->type == UV_TCP &&
-        (stream->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
-      /* Give other processes a chance to accept connections. */
-      struct timespec timeout = { 0, 1 };
-      nanosleep(&timeout, NULL);
-    }
-  }
-}
-
-
-#undef UV_DEC_BACKLOG
-
-
-int uv_accept(uv_stream_t* server, uv_stream_t* client) {
-  int err;
-
-  assert(server->loop == client->loop);
-
-  if (server->accepted_fd == -1)
-    return UV_EAGAIN;
-
-  switch (client->type) {
-    case UV_NAMED_PIPE:
-    case UV_TCP:
-      err = uv__stream_open(client,
-                            server->accepted_fd,
-                            UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-      if (err) {
-        /* TODO handle error */
-        uv__close(server->accepted_fd);
-        goto done;
-      }
-      break;
-
-    case UV_UDP:
-      err = uv_udp_open((uv_udp_t*) client, server->accepted_fd);
-      if (err) {
-        uv__close(server->accepted_fd);
-        goto done;
-      }
-      break;
-
-    default:
-      return UV_EINVAL;
-  }
-
-  client->flags |= UV_HANDLE_BOUND;
-
-done:
-  /* Process queued fds */
-  if (server->queued_fds != NULL) {
-    uv__stream_queued_fds_t* queued_fds;
-
-    queued_fds = (uv__stream_queued_fds_t*)(server->queued_fds);
-
-    /* Read first */
-    server->accepted_fd = queued_fds->fds[0];
-
-    /* All read, free */
-    assert(queued_fds->offset > 0);
-    if (--queued_fds->offset == 0) {
-      uv__free(queued_fds);
-      server->queued_fds = NULL;
-    } else {
-      /* Shift rest */
-      memmove(queued_fds->fds,
-              queued_fds->fds + 1,
-              queued_fds->offset * sizeof(*queued_fds->fds));
-    }
-  } else {
-    server->accepted_fd = -1;
-    if (err == 0)
-      uv__io_start(server->loop, &server->io_watcher, POLLIN);
-  }
-  return err;
-}
-
-
-int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
-  int err;
-
-  switch (stream->type) {
-  case UV_TCP:
-    err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
-    break;
-
-  case UV_NAMED_PIPE:
-    err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
-    break;
-
-  default:
-    err = UV_EINVAL;
-  }
-
-  if (err == 0)
-    uv__handle_start(stream);
-
-  return err;
-}
-
-
-static void uv__drain(uv_stream_t* stream) {
-  uv_shutdown_t* req;
-  int err;
-
-  assert(QUEUE_EMPTY(&stream->write_queue));
-  uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
-  uv__stream_osx_interrupt_select(stream);
-
-  /* Shutdown? */
-  if ((stream->flags & UV_HANDLE_SHUTTING) &&
-      !(stream->flags & UV_HANDLE_CLOSING) &&
-      !(stream->flags & UV_HANDLE_SHUT)) {
-    assert(stream->shutdown_req);
-
-    req = stream->shutdown_req;
-    stream->shutdown_req = NULL;
-    stream->flags &= ~UV_HANDLE_SHUTTING;
-    uv__req_unregister(stream->loop, req);
-
-    err = 0;
-    if (shutdown(uv__stream_fd(stream), SHUT_WR))
-      err = UV__ERR(errno);
-
-    if (err == 0)
-      stream->flags |= UV_HANDLE_SHUT;
-
-    if (req->cb != NULL)
-      req->cb(req, err);
-  }
-}
-
-
-static ssize_t uv__writev(int fd, struct iovec* vec, size_t n) {
-  if (n == 1)
-    return write(fd, vec->iov_base, vec->iov_len);
-  else
-    return writev(fd, vec, n);
-}
-
-
-static size_t uv__write_req_size(uv_write_t* req) {
-  size_t size;
-
-  assert(req->bufs != NULL);
-  size = uv__count_bufs(req->bufs + req->write_index,
-                        req->nbufs - req->write_index);
-  assert(req->handle->write_queue_size >= size);
-
-  return size;
-}
-
-
-/* Returns 1 if all write request data has been written, or 0 if there is still
- * more data to write.
- *
- * Note: the return value only says something about the *current* request.
- * There may still be other write requests sitting in the queue.
- */
-static int uv__write_req_update(uv_stream_t* stream,
-                                uv_write_t* req,
-                                size_t n) {
-  uv_buf_t* buf;
-  size_t len;
-
-  assert(n <= stream->write_queue_size);
-  stream->write_queue_size -= n;
-
-  buf = req->bufs + req->write_index;
-
-  do {
-    len = n < buf->len ? n : buf->len;
-    buf->base += len;
-    buf->len -= len;
-    buf += (buf->len == 0);  /* Advance to next buffer if this one is empty. */
-    n -= len;
-  } while (n > 0);
-
-  req->write_index = buf - req->bufs;
-
-  return req->write_index == req->nbufs;
-}
-
-
-static void uv__write_req_finish(uv_write_t* req) {
-  uv_stream_t* stream = req->handle;
-
-  /* Pop the req off tcp->write_queue. */
-  QUEUE_REMOVE(&req->queue);
-
-  /* Only free when there was no error. On error, we touch up write_queue_size
-   * right before making the callback. The reason we don't do that right away
-   * is that a write_queue_size > 0 is our only way to signal to the user that
-   * they should stop writing - which they should if we got an error. Something
-   * to revisit in future revisions of the libuv API.
-   */
-  if (req->error == 0) {
-    if (req->bufs != req->bufsml)
-      uv__free(req->bufs);
-    req->bufs = NULL;
-  }
-
-  /* Add it to the write_completed_queue where it will have its
-   * callback called in the near future.
-   */
-  QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue);
-  uv__io_feed(stream->loop, &stream->io_watcher);
-}
-
-
-static int uv__handle_fd(uv_handle_t* handle) {
-  switch (handle->type) {
-    case UV_NAMED_PIPE:
-    case UV_TCP:
-      return ((uv_stream_t*) handle)->io_watcher.fd;
-
-    case UV_UDP:
-      return ((uv_udp_t*) handle)->io_watcher.fd;
-
-    default:
-      return -1;
-  }
-}
-
-static void uv__write(uv_stream_t* stream) {
-  struct iovec* iov;
-  QUEUE* q;
-  uv_write_t* req;
-  int iovmax;
-  int iovcnt;
-  ssize_t n;
-  int err;
-
-start:
-
-  assert(uv__stream_fd(stream) >= 0);
-
-  if (QUEUE_EMPTY(&stream->write_queue))
-    return;
-
-  q = QUEUE_HEAD(&stream->write_queue);
-  req = QUEUE_DATA(q, uv_write_t, queue);
-  assert(req->handle == stream);
-
-  /*
-   * Cast to iovec. We had to have our own uv_buf_t instead of iovec
-   * because Windows's WSABUF is not an iovec.
-   */
-  assert(sizeof(uv_buf_t) == sizeof(struct iovec));
-  iov = (struct iovec*) &(req->bufs[req->write_index]);
-  iovcnt = req->nbufs - req->write_index;
-
-  iovmax = uv__getiovmax();
-
-  /* Limit iov count to avoid EINVALs from writev() */
-  if (iovcnt > iovmax)
-    iovcnt = iovmax;
-
-  /*
-   * Now do the actual writev. Note that we've been updating the pointers
-   * inside the iov each time we write. So there is no need to offset it.
-   */
-
-  if (req->send_handle) {
-    int fd_to_send;
-    struct msghdr msg;
-    struct cmsghdr *cmsg;
-    union {
-      char data[64];
-      struct cmsghdr alias;
-    } scratch;
-
-    if (uv__is_closing(req->send_handle)) {
-      err = UV_EBADF;
-      goto error;
-    }
-
-    fd_to_send = uv__handle_fd((uv_handle_t*) req->send_handle);
-
-    memset(&scratch, 0, sizeof(scratch));
-
-    assert(fd_to_send >= 0);
-
-    msg.msg_name = NULL;
-    msg.msg_namelen = 0;
-    msg.msg_iov = iov;
-    msg.msg_iovlen = iovcnt;
-    msg.msg_flags = 0;
-
-    msg.msg_control = &scratch.alias;
-    msg.msg_controllen = CMSG_SPACE(sizeof(fd_to_send));
-
-    cmsg = CMSG_FIRSTHDR(&msg);
-    cmsg->cmsg_level = SOL_SOCKET;
-    cmsg->cmsg_type = SCM_RIGHTS;
-    cmsg->cmsg_len = CMSG_LEN(sizeof(fd_to_send));
-
-    /* silence aliasing warning */
-    {
-      void* pv = CMSG_DATA(cmsg);
-      int* pi = (int*)pv;
-      *pi = fd_to_send;
-    }
-
-    do
-      n = sendmsg(uv__stream_fd(stream), &msg, 0);
-    while (n == -1 && RETRY_ON_WRITE_ERROR(errno));
-
-    /* Ensure the handle isn't sent again in case this is a partial write. */
-    if (n >= 0)
-      req->send_handle = NULL;
-  } else {
-    do
-      n = uv__writev(uv__stream_fd(stream), iov, iovcnt);
-    while (n == -1 && RETRY_ON_WRITE_ERROR(errno));
-  }
-
-  if (n == -1 && !IS_TRANSIENT_WRITE_ERROR(errno, req->send_handle)) {
-    err = UV__ERR(errno);
-    goto error;
-  }
-
-  if (n >= 0 && uv__write_req_update(stream, req, n)) {
-    uv__write_req_finish(req);
-    return;  /* TODO(bnoordhuis) Start trying to write the next request. */
-  }
-
-  /* If this is a blocking stream, try again. */
-  if (stream->flags & UV_HANDLE_BLOCKING_WRITES)
-    goto start;
-
-  /* We're not done. */
-  uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
-
-  /* Notify select() thread about state change */
-  uv__stream_osx_interrupt_select(stream);
-
-  return;
-
-error:
-  req->error = err;
-  uv__write_req_finish(req);
-  uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
-  if (!uv__io_active(&stream->io_watcher, POLLIN))
-    uv__handle_stop(stream);
-  uv__stream_osx_interrupt_select(stream);
-}
-
-
-static void uv__write_callbacks(uv_stream_t* stream) {
-  uv_write_t* req;
-  QUEUE* q;
-  QUEUE pq;
-
-  if (QUEUE_EMPTY(&stream->write_completed_queue))
-    return;
-
-  QUEUE_MOVE(&stream->write_completed_queue, &pq);
-
-  while (!QUEUE_EMPTY(&pq)) {
-    /* Pop a req off write_completed_queue. */
-    q = QUEUE_HEAD(&pq);
-    req = QUEUE_DATA(q, uv_write_t, queue);
-    QUEUE_REMOVE(q);
-    uv__req_unregister(stream->loop, req);
-
-    if (req->bufs != NULL) {
-      stream->write_queue_size -= uv__write_req_size(req);
-      if (req->bufs != req->bufsml)
-        uv__free(req->bufs);
-      req->bufs = NULL;
-    }
-
-    /* NOTE: call callback AFTER freeing the request data. */
-    if (req->cb)
-      req->cb(req, req->error);
-  }
-}
-
-
-uv_handle_type uv__handle_type(int fd) {
-  struct sockaddr_storage ss;
-  socklen_t sslen;
-  socklen_t len;
-  int type;
-
-  memset(&ss, 0, sizeof(ss));
-  sslen = sizeof(ss);
-
-  if (getsockname(fd, (struct sockaddr*)&ss, &sslen))
-    return UV_UNKNOWN_HANDLE;
-
-  len = sizeof type;
-
-  if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &len))
-    return UV_UNKNOWN_HANDLE;
-
-  if (type == SOCK_STREAM) {
-#if defined(_AIX) || defined(__DragonFly__)
-    /* on AIX/DragonFly the getsockname call returns an empty sa structure
-     * for sockets of type AF_UNIX.  For all other types it will
-     * return a properly filled in structure.
-     */
-    if (sslen == 0)
-      return UV_NAMED_PIPE;
-#endif
-    switch (ss.ss_family) {
-      case AF_UNIX:
-        return UV_NAMED_PIPE;
-      case AF_INET:
-      case AF_INET6:
-        return UV_TCP;
-      }
-  }
-
-  if (type == SOCK_DGRAM &&
-      (ss.ss_family == AF_INET || ss.ss_family == AF_INET6))
-    return UV_UDP;
-
-  return UV_UNKNOWN_HANDLE;
-}
-
-
-static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) {
-  stream->flags |= UV_HANDLE_READ_EOF;
-  uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
-  if (!uv__io_active(&stream->io_watcher, POLLOUT))
-    uv__handle_stop(stream);
-  uv__stream_osx_interrupt_select(stream);
-  stream->read_cb(stream, UV_EOF, buf);
-  stream->flags &= ~UV_HANDLE_READING;
-}
-
-
-static int uv__stream_queue_fd(uv_stream_t* stream, int fd) {
-  uv__stream_queued_fds_t* queued_fds;
-  unsigned int queue_size;
-
-  queued_fds = (uv__stream_queued_fds_t*)stream->queued_fds;
-  if (queued_fds == NULL) {
-    queue_size = 8;
-    queued_fds = (uv__stream_queued_fds_t*)
-        uv__malloc((queue_size - 1) * sizeof(*queued_fds->fds) +
-                   sizeof(*queued_fds));
-    if (queued_fds == NULL)
-      return UV_ENOMEM;
-    queued_fds->size = queue_size;
-    queued_fds->offset = 0;
-    stream->queued_fds = queued_fds;
-
-    /* Grow */
-  } else if (queued_fds->size == queued_fds->offset) {
-    queue_size = queued_fds->size + 8;
-    queued_fds = (uv__stream_queued_fds_t*)
-        uv__realloc(queued_fds, (queue_size - 1) * sizeof(*queued_fds->fds) +
-                    sizeof(*queued_fds));
-
-    /*
-     * Allocation failure, report back.
-     * NOTE: if it is fatal - sockets will be closed in uv__stream_close
-     */
-    if (queued_fds == NULL)
-      return UV_ENOMEM;
-    queued_fds->size = queue_size;
-    stream->queued_fds = queued_fds;
-  }
-
-  /* Put fd in a queue */
-  queued_fds->fds[queued_fds->offset++] = fd;
-
-  return 0;
-}
-
-
-#define UV__CMSG_FD_COUNT 64
-#define UV__CMSG_FD_SIZE (UV__CMSG_FD_COUNT * sizeof(int))
-
-
-static int uv__stream_recv_cmsg(uv_stream_t* stream, struct msghdr* msg) {
-  struct cmsghdr* cmsg;
-
-  for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) {
-    char* start;
-    char* end;
-    int err;
-    void* pv;
-    int* pi;
-    unsigned int i;
-    unsigned int count;
-
-    if (cmsg->cmsg_type != SCM_RIGHTS) {
-      fprintf(stderr, "ignoring non-SCM_RIGHTS ancillary data: %d\n",
-          cmsg->cmsg_type);
-      continue;
-    }
-
-    /* silence aliasing warning */
-    pv = CMSG_DATA(cmsg);
-    pi = (int*)pv;
-
-    /* Count available fds */
-    start = (char*) cmsg;
-    end = (char*) cmsg + cmsg->cmsg_len;
-    count = 0;
-    while (start + CMSG_LEN(count * sizeof(*pi)) < end)
-      count++;
-    assert(start + CMSG_LEN(count * sizeof(*pi)) == end);
-
-    for (i = 0; i < count; i++) {
-      /* Already has accepted fd, queue now */
-      if (stream->accepted_fd != -1) {
-        err = uv__stream_queue_fd(stream, pi[i]);
-        if (err != 0) {
-          /* Close rest */
-          for (; i < count; i++)
-            uv__close(pi[i]);
-          return err;
-        }
-      } else {
-        stream->accepted_fd = pi[i];
-      }
-    }
-  }
-
-  return 0;
-}
-
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wgnu-folding-constant"
-# pragma clang diagnostic ignored "-Wvla-extension"
-#endif
-
-static void uv__read(uv_stream_t* stream) {
-  uv_buf_t buf;
-  ssize_t nread;
-  struct msghdr msg;
-  char cmsg_space[CMSG_SPACE(UV__CMSG_FD_SIZE)];
-  int count;
-  int err;
-  int is_ipc;
-
-  stream->flags &= ~UV_HANDLE_READ_PARTIAL;
-
-  /* Prevent loop starvation when the data comes in as fast as (or faster than)
-   * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
-   */
-  count = 32;
-
-  is_ipc = stream->type == UV_NAMED_PIPE && ((uv_pipe_t*) stream)->ipc;
-
-  /* XXX: Maybe instead of having UV_HANDLE_READING we just test if
-   * tcp->read_cb is NULL or not?
-   */
-  while (stream->read_cb
-      && (stream->flags & UV_HANDLE_READING)
-      && (count-- > 0)) {
-    assert(stream->alloc_cb != NULL);
-
-    buf = uv_buf_init(NULL, 0);
-    stream->alloc_cb((uv_handle_t*)stream, 64 * 1024, &buf);
-    if (buf.base == NULL || buf.len == 0) {
-      /* User indicates it can't or won't handle the read. */
-      stream->read_cb(stream, UV_ENOBUFS, &buf);
-      return;
-    }
-
-    assert(buf.base != NULL);
-    assert(uv__stream_fd(stream) >= 0);
-
-    if (!is_ipc) {
-      do {
-        nread = read(uv__stream_fd(stream), buf.base, buf.len);
-      }
-      while (nread < 0 && errno == EINTR);
-    } else {
-      /* ipc uses recvmsg */
-      msg.msg_flags = 0;
-      msg.msg_iov = (struct iovec*) &buf;
-      msg.msg_iovlen = 1;
-      msg.msg_name = NULL;
-      msg.msg_namelen = 0;
-      /* Set up to receive a descriptor even if one isn't in the message */
-      msg.msg_controllen = sizeof(cmsg_space);
-      msg.msg_control = cmsg_space;
-
-      do {
-        nread = uv__recvmsg(uv__stream_fd(stream), &msg, 0);
-      }
-      while (nread < 0 && errno == EINTR);
-    }
-
-    if (nread < 0) {
-      /* Error */
-      if (errno == EAGAIN || errno == EWOULDBLOCK) {
-        /* Wait for the next one. */
-        if (stream->flags & UV_HANDLE_READING) {
-          uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
-          uv__stream_osx_interrupt_select(stream);
-        }
-        stream->read_cb(stream, 0, &buf);
-#if defined(__CYGWIN__) || defined(__MSYS__)
-      } else if (errno == ECONNRESET && stream->type == UV_NAMED_PIPE) {
-        uv__stream_eof(stream, &buf);
-        return;
-#endif
-      } else {
-        /* Error. User should call uv_close(). */
-        stream->read_cb(stream, UV__ERR(errno), &buf);
-        if (stream->flags & UV_HANDLE_READING) {
-          stream->flags &= ~UV_HANDLE_READING;
-          uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
-          if (!uv__io_active(&stream->io_watcher, POLLOUT))
-            uv__handle_stop(stream);
-          uv__stream_osx_interrupt_select(stream);
-        }
-      }
-      return;
-    } else if (nread == 0) {
-      uv__stream_eof(stream, &buf);
-      return;
-    } else {
-      /* Successful read */
-      ssize_t buflen = buf.len;
-
-      if (is_ipc) {
-        err = uv__stream_recv_cmsg(stream, &msg);
-        if (err != 0) {
-          stream->read_cb(stream, err, &buf);
-          return;
-        }
-      }
-
-#if defined(__MVS__)
-      if (is_ipc && msg.msg_controllen > 0) {
-        uv_buf_t blankbuf;
-        int nread;
-        struct iovec *old;
-
-        blankbuf.base = 0;
-        blankbuf.len = 0;
-        old = msg.msg_iov;
-        msg.msg_iov = (struct iovec*) &blankbuf;
-        nread = 0;
-        do {
-          nread = uv__recvmsg(uv__stream_fd(stream), &msg, 0);
-          err = uv__stream_recv_cmsg(stream, &msg);
-          if (err != 0) {
-            stream->read_cb(stream, err, &buf);
-            msg.msg_iov = old;
-            return;
-          }
-        } while (nread == 0 && msg.msg_controllen > 0);
-        msg.msg_iov = old;
-      }
-#endif
-      stream->read_cb(stream, nread, &buf);
-
-      /* Return if we didn't fill the buffer, there is no more data to read. */
-      if (nread < buflen) {
-        stream->flags |= UV_HANDLE_READ_PARTIAL;
-        return;
-      }
-    }
-  }
-}
-
-
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-
-#undef UV__CMSG_FD_COUNT
-#undef UV__CMSG_FD_SIZE
-
-
-int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
-  assert(stream->type == UV_TCP ||
-         stream->type == UV_TTY ||
-         stream->type == UV_NAMED_PIPE);
-
-  if (!(stream->flags & UV_HANDLE_WRITABLE) ||
-      stream->flags & UV_HANDLE_SHUT ||
-      stream->flags & UV_HANDLE_SHUTTING ||
-      uv__is_closing(stream)) {
-    return UV_ENOTCONN;
-  }
-
-  assert(uv__stream_fd(stream) >= 0);
-
-  /* Initialize request */
-  uv__req_init(stream->loop, req, UV_SHUTDOWN);
-  req->handle = stream;
-  req->cb = cb;
-  stream->shutdown_req = req;
-  stream->flags |= UV_HANDLE_SHUTTING;
-
-  uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
-  uv__stream_osx_interrupt_select(stream);
-
-  return 0;
-}
-
-
-static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
-  uv_stream_t* stream;
-
-  stream = container_of(w, uv_stream_t, io_watcher);
-
-  assert(stream->type == UV_TCP ||
-         stream->type == UV_NAMED_PIPE ||
-         stream->type == UV_TTY);
-  assert(!(stream->flags & UV_HANDLE_CLOSING));
-
-  if (stream->connect_req) {
-    uv__stream_connect(stream);
-    return;
-  }
-
-  assert(uv__stream_fd(stream) >= 0);
-
-  /* Ignore POLLHUP here. Even if it's set, there may still be data to read. */
-  if (events & (POLLIN | POLLERR | POLLHUP))
-    uv__read(stream);
-
-  if (uv__stream_fd(stream) == -1)
-    return;  /* read_cb closed stream. */
-
-  /* Short-circuit iff POLLHUP is set, the user is still interested in read
-   * events and uv__read() reported a partial read but not EOF. If the EOF
-   * flag is set, uv__read() called read_cb with err=UV_EOF and we don't
-   * have to do anything. If the partial read flag is not set, we can't
-   * report the EOF yet because there is still data to read.
-   */
-  if ((events & POLLHUP) &&
-      (stream->flags & UV_HANDLE_READING) &&
-      (stream->flags & UV_HANDLE_READ_PARTIAL) &&
-      !(stream->flags & UV_HANDLE_READ_EOF)) {
-    uv_buf_t buf = { NULL, 0 };
-    uv__stream_eof(stream, &buf);
-  }
-
-  if (uv__stream_fd(stream) == -1)
-    return;  /* read_cb closed stream. */
-
-  if (events & (POLLOUT | POLLERR | POLLHUP)) {
-    uv__write(stream);
-    uv__write_callbacks(stream);
-
-    /* Write queue drained. */
-    if (QUEUE_EMPTY(&stream->write_queue))
-      uv__drain(stream);
-  }
-}
-
-
-/**
- * We get called here from directly following a call to connect(2).
- * In order to determine if we've errored out or succeeded must call
- * getsockopt.
- */
-static void uv__stream_connect(uv_stream_t* stream) {
-  int error;
-  uv_connect_t* req = stream->connect_req;
-  socklen_t errorsize = sizeof(int);
-
-  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE);
-  assert(req);
-
-  if (stream->delayed_error) {
-    /* To smooth over the differences between unixes errors that
-     * were reported synchronously on the first connect can be delayed
-     * until the next tick--which is now.
-     */
-    error = stream->delayed_error;
-    stream->delayed_error = 0;
-  } else {
-    /* Normal situation: we need to get the socket error from the kernel. */
-    assert(uv__stream_fd(stream) >= 0);
-    getsockopt(uv__stream_fd(stream),
-               SOL_SOCKET,
-               SO_ERROR,
-               &error,
-               &errorsize);
-    error = UV__ERR(error);
-  }
-
-  if (error == UV__ERR(EINPROGRESS))
-    return;
-
-  stream->connect_req = NULL;
-  uv__req_unregister(stream->loop, req);
-
-  if (error < 0 || QUEUE_EMPTY(&stream->write_queue)) {
-    uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
-  }
-
-  if (req->cb)
-    req->cb(req, error);
-
-  if (uv__stream_fd(stream) == -1)
-    return;
-
-  if (error < 0) {
-    uv__stream_flush_write_queue(stream, UV_ECANCELED);
-    uv__write_callbacks(stream);
-  }
-}
-
-
-int uv_write2(uv_write_t* req,
-              uv_stream_t* stream,
-              const uv_buf_t bufs[],
-              unsigned int nbufs,
-              uv_stream_t* send_handle,
-              uv_write_cb cb) {
-  int empty_queue;
-
-  assert(nbufs > 0);
-  assert((stream->type == UV_TCP ||
-          stream->type == UV_NAMED_PIPE ||
-          stream->type == UV_TTY) &&
-         "uv_write (unix) does not yet support other types of streams");
-
-  if (uv__stream_fd(stream) < 0)
-    return UV_EBADF;
-
-  if (!(stream->flags & UV_HANDLE_WRITABLE))
-    return -EPIPE;
-
-  if (send_handle) {
-    if (stream->type != UV_NAMED_PIPE || !((uv_pipe_t*)stream)->ipc)
-      return UV_EINVAL;
-
-    /* XXX We abuse uv_write2() to send over UDP handles to child processes.
-     * Don't call uv__stream_fd() on those handles, it's a macro that on OS X
-     * evaluates to a function that operates on a uv_stream_t with a couple of
-     * OS X specific fields. On other Unices it does (handle)->io_watcher.fd,
-     * which works but only by accident.
-     */
-    if (uv__handle_fd((uv_handle_t*) send_handle) < 0)
-      return UV_EBADF;
-
-#if defined(__CYGWIN__) || defined(__MSYS__)
-    /* Cygwin recvmsg always sets msg_controllen to zero, so we cannot send it.
-       See https://github.com/mirror/newlib-cygwin/blob/86fc4bf0/winsup/cygwin/fhandler_socket.cc#L1736-L1743 */
-    return UV_ENOSYS;
-#endif
-  }
-
-  /* It's legal for write_queue_size > 0 even when the write_queue is empty;
-   * it means there are error-state requests in the write_completed_queue that
-   * will touch up write_queue_size later, see also uv__write_req_finish().
-   * We could check that write_queue is empty instead but that implies making
-   * a write() syscall when we know that the handle is in error mode.
-   */
-  empty_queue = (stream->write_queue_size == 0);
-
-  /* Initialize the req */
-  uv__req_init(stream->loop, req, UV_WRITE);
-  req->cb = cb;
-  req->handle = stream;
-  req->error = 0;
-  req->send_handle = send_handle;
-  QUEUE_INIT(&req->queue);
-
-  req->bufs = req->bufsml;
-  if (nbufs > ARRAY_SIZE(req->bufsml))
-    req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(bufs[0]));
-
-  if (req->bufs == NULL)
-    return UV_ENOMEM;
-
-  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
-  req->nbufs = nbufs;
-  req->write_index = 0;
-  stream->write_queue_size += uv__count_bufs(bufs, nbufs);
-
-  /* Append the request to write_queue. */
-  QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue);
-
-  /* If the queue was empty when this function began, we should attempt to
-   * do the write immediately. Otherwise start the write_watcher and wait
-   * for the fd to become writable.
-   */
-  if (stream->connect_req) {
-    /* Still connecting, do nothing. */
-  }
-  else if (empty_queue) {
-    uv__write(stream);
-  }
-  else {
-    /*
-     * blocking streams should never have anything in the queue.
-     * if this assert fires then somehow the blocking stream isn't being
-     * sufficiently flushed in uv__write.
-     */
-    assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
-    uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
-    uv__stream_osx_interrupt_select(stream);
-  }
-
-  return 0;
-}
-
-
-/* The buffers to be written must remain valid until the callback is called.
- * This is not required for the uv_buf_t array.
- */
-int uv_write(uv_write_t* req,
-             uv_stream_t* handle,
-             const uv_buf_t bufs[],
-             unsigned int nbufs,
-             uv_write_cb cb) {
-  return uv_write2(req, handle, bufs, nbufs, NULL, cb);
-}
-
-
-void uv_try_write_cb(uv_write_t* req, int status) {
-  /* Should not be called */
-  abort();
-}
-
-
-int uv_try_write(uv_stream_t* stream,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs) {
-  int r;
-  int has_pollout;
-  size_t written;
-  size_t req_size;
-  uv_write_t req;
-
-  /* Connecting or already writing some data */
-  if (stream->connect_req != NULL || stream->write_queue_size != 0)
-    return UV_EAGAIN;
-
-  has_pollout = uv__io_active(&stream->io_watcher, POLLOUT);
-
-  r = uv_write(&req, stream, bufs, nbufs, uv_try_write_cb);
-  if (r != 0)
-    return r;
-
-  /* Remove not written bytes from write queue size */
-  written = uv__count_bufs(bufs, nbufs);
-  if (req.bufs != NULL)
-    req_size = uv__write_req_size(&req);
-  else
-    req_size = 0;
-  written -= req_size;
-  stream->write_queue_size -= req_size;
-
-  /* Unqueue request, regardless of immediateness */
-  QUEUE_REMOVE(&req.queue);
-  uv__req_unregister(stream->loop, &req);
-  if (req.bufs != req.bufsml)
-    uv__free(req.bufs);
-  req.bufs = NULL;
-
-  /* Do not poll for writable, if we wasn't before calling this */
-  if (!has_pollout) {
-    uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
-    uv__stream_osx_interrupt_select(stream);
-  }
-
-  if (written == 0 && req_size != 0)
-    return req.error < 0 ? req.error : UV_EAGAIN;
-  else
-    return written;
-}
-
-
-int uv_read_start(uv_stream_t* stream,
-                  uv_alloc_cb alloc_cb,
-                  uv_read_cb read_cb) {
-  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
-      stream->type == UV_TTY);
-
-  if (stream->flags & UV_HANDLE_CLOSING)
-    return UV_EINVAL;
-
-  if (!(stream->flags & UV_HANDLE_READABLE))
-    return -ENOTCONN;
-
-  /* The UV_HANDLE_READING flag is irrelevant of the state of the tcp - it just
-   * expresses the desired state of the user.
-   */
-  stream->flags |= UV_HANDLE_READING;
-
-  /* TODO: try to do the read inline? */
-  /* TODO: keep track of tcp state. If we've gotten a EOF then we should
-   * not start the IO watcher.
-   */
-  assert(uv__stream_fd(stream) >= 0);
-  assert(alloc_cb);
-
-  stream->read_cb = read_cb;
-  stream->alloc_cb = alloc_cb;
-
-  uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
-  uv__handle_start(stream);
-  uv__stream_osx_interrupt_select(stream);
-
-  return 0;
-}
-
-
-int uv_read_stop(uv_stream_t* stream) {
-  if (!(stream->flags & UV_HANDLE_READING))
-    return 0;
-
-  stream->flags &= ~UV_HANDLE_READING;
-  uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
-  if (!uv__io_active(&stream->io_watcher, POLLOUT))
-    uv__handle_stop(stream);
-  uv__stream_osx_interrupt_select(stream);
-
-  stream->read_cb = NULL;
-  stream->alloc_cb = NULL;
-  return 0;
-}
-
-
-int uv_is_readable(const uv_stream_t* stream) {
-  return !!(stream->flags & UV_HANDLE_READABLE);
-}
-
-
-int uv_is_writable(const uv_stream_t* stream) {
-  return !!(stream->flags & UV_HANDLE_WRITABLE);
-}
-
-
-#if defined(__APPLE__)
-int uv___stream_fd(const uv_stream_t* handle) {
-  const uv__stream_select_t* s;
-
-  assert(handle->type == UV_TCP ||
-         handle->type == UV_TTY ||
-         handle->type == UV_NAMED_PIPE);
-
-  s = (const uv__stream_select_t*)handle->select;
-  if (s != NULL)
-    return s->fd;
-
-  return handle->io_watcher.fd;
-}
-#endif /* defined(__APPLE__) */
-
-
-void uv__stream_close(uv_stream_t* handle) {
-  unsigned int i;
-  uv__stream_queued_fds_t* queued_fds;
-
-#if defined(__APPLE__)
-  /* Terminate select loop first */
-  if (handle->select != NULL) {
-    uv__stream_select_t* s;
-
-    s = (uv__stream_select_t*)handle->select;
-
-    uv_sem_post(&s->close_sem);
-    uv_sem_post(&s->async_sem);
-    uv__stream_osx_interrupt_select(handle);
-    uv_thread_join(&s->thread);
-    uv_sem_destroy(&s->close_sem);
-    uv_sem_destroy(&s->async_sem);
-    uv__close(s->fake_fd);
-    uv__close(s->int_fd);
-    uv_close((uv_handle_t*) &s->async, uv__stream_osx_cb_close);
-
-    handle->select = NULL;
-  }
-#endif /* defined(__APPLE__) */
-
-  uv__io_close(handle->loop, &handle->io_watcher);
-  uv_read_stop(handle);
-  uv__handle_stop(handle);
-  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-
-  if (handle->io_watcher.fd != -1) {
-    /* Don't close stdio file descriptors.  Nothing good comes from it. */
-    if (handle->io_watcher.fd > STDERR_FILENO)
-      uv__close(handle->io_watcher.fd);
-    handle->io_watcher.fd = -1;
-  }
-
-  if (handle->accepted_fd != -1) {
-    uv__close(handle->accepted_fd);
-    handle->accepted_fd = -1;
-  }
-
-  /* Close all queued fds */
-  if (handle->queued_fds != NULL) {
-    queued_fds = (uv__stream_queued_fds_t*)(handle->queued_fds);
-    for (i = 0; i < queued_fds->offset; i++)
-      uv__close(queued_fds->fds[i]);
-    uv__free(handle->queued_fds);
-    handle->queued_fds = NULL;
-  }
-
-  assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
-}
-
-
-int uv_stream_set_blocking(uv_stream_t* handle, int blocking) {
-  /* Don't need to check the file descriptor, uv__nonblock()
-   * will fail with EBADF if it's not valid.
-   */
-  return uv__nonblock(uv__stream_fd(handle), !blocking);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/sysinfo-loadavg.cpp b/wpiutil/src/main/native/libuv/src/unix/sysinfo-loadavg.cpp
deleted file mode 100644
index ebad0e8..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/sysinfo-loadavg.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/* Copyright libuv project contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdint.h>
-#include <sys/sysinfo.h>
-
-void uv_loadavg(double avg[3]) {
-  struct sysinfo info;
-
-  if (sysinfo(&info) < 0) return;
-
-  avg[0] = (double) info.loads[0] / 65536.0;
-  avg[1] = (double) info.loads[1] / 65536.0;
-  avg[2] = (double) info.loads[2] / 65536.0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/tcp.cpp b/wpiutil/src/main/native/libuv/src/unix/tcp.cpp
deleted file mode 100644
index 8cedcd6..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/tcp.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <assert.h>
-#include <errno.h>
-
-
-static int new_socket(uv_tcp_t* handle, int domain, unsigned long flags) {
-  struct sockaddr_storage saddr;
-  socklen_t slen;
-  int sockfd;
-  int err;
-
-  err = uv__socket(domain, SOCK_STREAM, 0);
-  if (err < 0)
-    return err;
-  sockfd = err;
-
-  err = uv__stream_open((uv_stream_t*) handle, sockfd, flags);
-  if (err) {
-    uv__close(sockfd);
-    return err;
-  }
-
-  if (flags & UV_HANDLE_BOUND) {
-    /* Bind this new socket to an arbitrary port */
-    slen = sizeof(saddr);
-    memset(&saddr, 0, sizeof(saddr));
-    if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen)) {
-      uv__close(sockfd);
-      return UV__ERR(errno);
-    }
-
-    if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen)) {
-      uv__close(sockfd);
-      return UV__ERR(errno);
-    }
-  }
-
-  return 0;
-}
-
-
-static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) {
-  struct sockaddr_storage saddr;
-  socklen_t slen;
-
-  if (domain == AF_UNSPEC) {
-    handle->flags |= flags;
-    return 0;
-  }
-
-  if (uv__stream_fd(handle) != -1) {
-
-    if (flags & UV_HANDLE_BOUND) {
-
-      if (handle->flags & UV_HANDLE_BOUND) {
-        /* It is already bound to a port. */
-        handle->flags |= flags;
-        return 0;
-      }
-
-      /* Query to see if tcp socket is bound. */
-      slen = sizeof(saddr);
-      memset(&saddr, 0, sizeof(saddr));
-      if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen))
-        return UV__ERR(errno);
-
-      if ((saddr.ss_family == AF_INET6 &&
-          ((struct sockaddr_in6*) &saddr)->sin6_port != 0) ||
-          (saddr.ss_family == AF_INET &&
-          ((struct sockaddr_in*) &saddr)->sin_port != 0)) {
-        /* Handle is already bound to a port. */
-        handle->flags |= flags;
-        return 0;
-      }
-
-      /* Bind to arbitrary port */
-      if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen))
-        return UV__ERR(errno);
-    }
-
-    handle->flags |= flags;
-    return 0;
-  }
-
-  return new_socket(handle, domain, flags);
-}
-
-
-int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) {
-  int domain;
-
-  /* Use the lower 8 bits for the domain */
-  domain = flags & 0xFF;
-  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
-    return UV_EINVAL;
-
-  if (flags & ~0xFF)
-    return UV_EINVAL;
-
-  uv__stream_init(loop, (uv_stream_t*)tcp, UV_TCP);
-
-  /* If anything fails beyond this point we need to remove the handle from
-   * the handle queue, since it was added by uv__handle_init in uv_stream_init.
-   */
-
-  if (domain != AF_UNSPEC) {
-    int err = maybe_new_socket(tcp, domain, 0);
-    if (err) {
-      QUEUE_REMOVE(&tcp->handle_queue);
-      return err;
-    }
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* tcp) {
-  return uv_tcp_init_ex(loop, tcp, AF_UNSPEC);
-}
-
-
-int uv__tcp_bind(uv_tcp_t* tcp,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 unsigned int flags) {
-  int err;
-  int on;
-
-  /* Cannot set IPv6-only mode on non-IPv6 socket. */
-  if ((flags & UV_TCP_IPV6ONLY) && addr->sa_family != AF_INET6)
-    return UV_EINVAL;
-
-  err = maybe_new_socket(tcp, addr->sa_family, 0);
-  if (err)
-    return err;
-
-  on = 1;
-  if (setsockopt(tcp->io_watcher.fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
-    return UV__ERR(errno);
-
-#ifndef __OpenBSD__
-#ifdef IPV6_V6ONLY
-  if (addr->sa_family == AF_INET6) {
-    on = (flags & UV_TCP_IPV6ONLY) != 0;
-    if (setsockopt(tcp->io_watcher.fd,
-                   IPPROTO_IPV6,
-                   IPV6_V6ONLY,
-                   &on,
-                   sizeof on) == -1) {
-#if defined(__MVS__)
-      if (errno == EOPNOTSUPP)
-        return UV_EINVAL;
-#endif
-      return UV__ERR(errno);
-    }
-  }
-#endif
-#endif
-
-  errno = 0;
-  if (bind(tcp->io_watcher.fd, addr, addrlen) && errno != EADDRINUSE) {
-    if (errno == EAFNOSUPPORT)
-      /* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
-       * socket created with AF_INET to an AF_INET6 address or vice versa. */
-      return UV_EINVAL;
-    return UV__ERR(errno);
-  }
-  tcp->delayed_error = UV__ERR(errno);
-
-  tcp->flags |= UV_HANDLE_BOUND;
-  if (addr->sa_family == AF_INET6)
-    tcp->flags |= UV_HANDLE_IPV6;
-
-  return 0;
-}
-
-
-int uv__tcp_connect(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen,
-                    uv_connect_cb cb) {
-  int err;
-  int r;
-
-  assert(handle->type == UV_TCP);
-
-  if (handle->connect_req != NULL)
-    return UV_EALREADY;  /* FIXME(bnoordhuis) UV_EINVAL or maybe UV_EBUSY. */
-
-  err = maybe_new_socket(handle,
-                         addr->sa_family,
-                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-  if (err)
-    return err;
-
-  handle->delayed_error = 0;
-
-  do {
-    errno = 0;
-    r = connect(uv__stream_fd(handle), addr, addrlen);
-  } while (r == -1 && errno == EINTR);
-
-  /* We not only check the return value, but also check the errno != 0.
-   * Because in rare cases connect() will return -1 but the errno
-   * is 0 (for example, on Android 4.3, OnePlus phone A0001_12_150227)
-   * and actually the tcp three-way handshake is completed.
-   */
-  if (r == -1 && errno != 0) {
-    if (errno == EINPROGRESS)
-      ; /* not an error */
-    else if (errno == ECONNREFUSED
-#if defined(__OpenBSD__)
-      || errno == EINVAL
-#endif
-      )
-    /* If we get ECONNREFUSED (Solaris) or EINVAL (OpenBSD) wait until the
-     * next tick to report the error. Solaris and OpenBSD wants to report
-     * immediately -- other unixes want to wait.
-     */
-      handle->delayed_error = UV__ERR(ECONNREFUSED);
-    else
-      return UV__ERR(errno);
-  }
-
-  uv__req_init(handle->loop, req, UV_CONNECT);
-  req->cb = cb;
-  req->handle = (uv_stream_t*) handle;
-  QUEUE_INIT(&req->queue);
-  handle->connect_req = req;
-
-  uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
-
-  if (handle->delayed_error)
-    uv__io_feed(handle->loop, &handle->io_watcher);
-
-  return 0;
-}
-
-
-int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
-  int err;
-
-  if (uv__fd_exists(handle->loop, sock))
-    return UV_EEXIST;
-
-  err = uv__nonblock(sock, 1);
-  if (err)
-    return err;
-
-  return uv__stream_open((uv_stream_t*)handle,
-                         sock,
-                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-}
-
-
-int uv_tcp_getsockname(const uv_tcp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  if (handle->delayed_error)
-    return handle->delayed_error;
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getsockname,
-                             name,
-                             namelen);
-}
-
-
-int uv_tcp_getpeername(const uv_tcp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  if (handle->delayed_error)
-    return handle->delayed_error;
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getpeername,
-                             name,
-                             namelen);
-}
-
-
-int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
-  static int single_accept = -1;
-  unsigned long flags;
-  int err;
-
-  if (tcp->delayed_error)
-    return tcp->delayed_error;
-
-  if (single_accept == -1) {
-    const char* val = getenv("UV_TCP_SINGLE_ACCEPT");
-    single_accept = (val != NULL && atoi(val) != 0);  /* Off by default. */
-  }
-
-  if (single_accept)
-    tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
-
-  flags = 0;
-#if defined(__MVS__)
-  /* on zOS the listen call does not bind automatically
-     if the socket is unbound. Hence the manual binding to
-     an arbitrary port is required to be done manually
-  */
-  flags |= UV_HANDLE_BOUND;
-#endif
-  err = maybe_new_socket(tcp, AF_INET, flags);
-  if (err)
-    return err;
-
-  if (listen(tcp->io_watcher.fd, backlog))
-    return UV__ERR(errno);
-
-  tcp->connection_cb = cb;
-  tcp->flags |= UV_HANDLE_BOUND;
-
-  /* Start listening for connections. */
-  tcp->io_watcher.cb = uv__server_io;
-  uv__io_start(tcp->loop, &tcp->io_watcher, POLLIN);
-
-  return 0;
-}
-
-
-int uv__tcp_nodelay(int fd, int on) {
-  if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)))
-    return UV__ERR(errno);
-  return 0;
-}
-
-
-int uv__tcp_keepalive(int fd, int on, unsigned int delay) {
-  if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)))
-    return UV__ERR(errno);
-
-#ifdef TCP_KEEPIDLE
-  if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay)))
-    return UV__ERR(errno);
-#endif
-
-  /* Solaris/SmartOS, if you don't support keep-alive,
-   * then don't advertise it in your system headers...
-   */
-  /* FIXME(bnoordhuis) That's possibly because sizeof(delay) should be 1. */
-#if defined(TCP_KEEPALIVE) && !defined(__sun)
-  if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay)))
-    return UV__ERR(errno);
-#endif
-
-  return 0;
-}
-
-
-int uv_tcp_nodelay(uv_tcp_t* handle, int on) {
-  int err;
-
-  if (uv__stream_fd(handle) != -1) {
-    err = uv__tcp_nodelay(uv__stream_fd(handle), on);
-    if (err)
-      return err;
-  }
-
-  if (on)
-    handle->flags |= UV_HANDLE_TCP_NODELAY;
-  else
-    handle->flags &= ~UV_HANDLE_TCP_NODELAY;
-
-  return 0;
-}
-
-
-int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
-  int err;
-
-  if (uv__stream_fd(handle) != -1) {
-    err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);
-    if (err)
-      return err;
-  }
-
-  if (on)
-    handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
-  else
-    handle->flags &= ~UV_HANDLE_TCP_KEEPALIVE;
-
-  /* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge
-   *      uv_tcp_t with an int that's almost never used...
-   */
-
-  return 0;
-}
-
-
-int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) {
-  if (enable)
-    handle->flags &= ~UV_HANDLE_TCP_SINGLE_ACCEPT;
-  else
-    handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
-  return 0;
-}
-
-
-void uv__tcp_close(uv_tcp_t* handle) {
-  uv__stream_close((uv_stream_t*)handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/thread.cpp b/wpiutil/src/main/native/libuv/src/unix/thread.cpp
deleted file mode 100644
index 012cd6a..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/thread.cpp
+++ /dev/null
@@ -1,844 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <pthread.h>
-#include <assert.h>
-#include <errno.h>
-
-#include <sys/time.h>
-#include <sys/resource.h>  /* getrlimit() */
-#include <unistd.h>  /* getpagesize() */
-
-#include <limits.h>
-
-#ifdef __MVS__
-#include <sys/ipc.h>
-#include <sys/sem.h>
-#endif
-
-#if defined(__GLIBC__) && !defined(__UCLIBC__)
-#include <gnu/libc-version.h>  /* gnu_get_libc_version() */
-#endif
-
-#undef NANOSEC
-#define NANOSEC ((uint64_t) 1e9)
-
-#if defined(PTHREAD_BARRIER_SERIAL_THREAD)
-STATIC_ASSERT(sizeof(uv_barrier_t) == sizeof(pthread_barrier_t));
-#endif
-
-/* Note: guard clauses should match uv_barrier_t's in include/uv/unix.h. */
-#if defined(_AIX) || \
-    defined(__OpenBSD__) || \
-    !defined(PTHREAD_BARRIER_SERIAL_THREAD)
-int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {
-  struct _uv_barrier* b;
-  int rc;
-
-  if (barrier == NULL || count == 0)
-    return UV_EINVAL;
-
-  b = (_uv_barrier*)uv__malloc(sizeof(*b));
-  if (b == NULL)
-    return UV_ENOMEM;
-
-  b->in = 0;
-  b->out = 0;
-  b->threshold = count;
-
-  rc = uv_mutex_init(&b->mutex);
-  if (rc != 0)
-    goto error2;
-
-  rc = uv_cond_init(&b->cond);
-  if (rc != 0)
-    goto error;
-
-  barrier->b = b;
-  return 0;
-
-error:
-  uv_mutex_destroy(&b->mutex);
-error2:
-  uv__free(b);
-  return rc;
-}
-
-int uv_barrier_wait(uv_barrier_t* barrier) {
-  struct _uv_barrier* b;
-  int last;
-
-  if (barrier == NULL || barrier->b == NULL)
-    return UV_EINVAL;
-
-  b = barrier->b;
-  /* Lock the mutex*/
-  uv_mutex_lock(&b->mutex);
-
-  if (++b->in == b->threshold) {
-    b->in = 0;
-    b->out = b->threshold;
-    uv_cond_signal(&b->cond);
-  } else {
-    do
-      uv_cond_wait(&b->cond, &b->mutex);
-    while (b->in != 0);
-  }
-
-  last = (--b->out == 0);
-  if (!last)
-    uv_cond_signal(&b->cond);  /* Not needed for last thread. */
-
-  uv_mutex_unlock(&b->mutex);
-  return last;
-}
-
-void uv_barrier_destroy(uv_barrier_t* barrier) {
-  struct _uv_barrier* b;
-
-  b = barrier->b;
-  uv_mutex_lock(&b->mutex);
-
-  assert(b->in == 0);
-  assert(b->out == 0);
-
-  if (b->in != 0 || b->out != 0)
-    abort();
-
-  uv_mutex_unlock(&b->mutex);
-  uv_mutex_destroy(&b->mutex);
-  uv_cond_destroy(&b->cond);
-
-  uv__free(barrier->b);
-  barrier->b = NULL;
-}
-
-#else
-
-int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {
-  return UV__ERR(pthread_barrier_init(barrier, NULL, count));
-}
-
-
-int uv_barrier_wait(uv_barrier_t* barrier) {
-  int rc;
-
-  rc = pthread_barrier_wait(barrier);
-  if (rc != 0)
-    if (rc != PTHREAD_BARRIER_SERIAL_THREAD)
-      abort();
-
-  return rc == PTHREAD_BARRIER_SERIAL_THREAD;
-}
-
-
-void uv_barrier_destroy(uv_barrier_t* barrier) {
-  if (pthread_barrier_destroy(barrier))
-    abort();
-}
-
-#endif
-
-
-/* On MacOS, threads other than the main thread are created with a reduced
- * stack size by default.  Adjust to RLIMIT_STACK aligned to the page size.
- *
- * On Linux, threads created by musl have a much smaller stack than threads
- * created by glibc (80 vs. 2048 or 4096 kB.)  Follow glibc for consistency.
- */
-static size_t thread_stack_size(void) {
-#if defined(__APPLE__) || defined(__linux__)
-  struct rlimit lim;
-
-  if (getrlimit(RLIMIT_STACK, &lim))
-    abort();
-
-  if (lim.rlim_cur != RLIM_INFINITY) {
-    /* pthread_attr_setstacksize() expects page-aligned values. */
-    lim.rlim_cur -= lim.rlim_cur % (rlim_t) getpagesize();
-
-    /* Musl's PTHREAD_STACK_MIN is 2 KB on all architectures, which is
-     * too small to safely receive signals on.
-     *
-     * Musl's PTHREAD_STACK_MIN + MINSIGSTKSZ == 8192 on arm64 (which has
-     * the largest MINSIGSTKSZ of the architectures that musl supports) so
-     * let's use that as a lower bound.
-     *
-     * We use a hardcoded value because PTHREAD_STACK_MIN + MINSIGSTKSZ
-     * is between 28 and 133 KB when compiling against glibc, depending
-     * on the architecture.
-     */
-    if (lim.rlim_cur >= 8192)
-      if (lim.rlim_cur >= (rlim_t) PTHREAD_STACK_MIN)
-        return lim.rlim_cur;
-  }
-#endif
-
-#if !defined(__linux__)
-  return 0;
-#elif defined(__PPC__) || defined(__ppc__) || defined(__powerpc__)
-  return 4 << 20;  /* glibc default. */
-#else
-  return 2 << 20;  /* glibc default. */
-#endif
-}
-
-
-int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
-  uv_thread_options_t params;
-  params.flags = UV_THREAD_NO_FLAGS;
-  return uv_thread_create_ex(tid, &params, entry, arg);
-}
-
-int uv_thread_create_ex(uv_thread_t* tid,
-                        const uv_thread_options_t* params,
-                        void (*entry)(void *arg),
-                        void *arg) {
-  int err;
-  pthread_attr_t* attr;
-  pthread_attr_t attr_storage;
-  size_t pagesize;
-  size_t stack_size;
-
-  stack_size =
-      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
-
-  attr = NULL;
-  if (stack_size == 0) {
-    stack_size = thread_stack_size();
-  } else {
-    pagesize = (size_t)getpagesize();
-    /* Round up to the nearest page boundary. */
-    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
-#ifdef PTHREAD_STACK_MIN
-    if (stack_size < (size_t) PTHREAD_STACK_MIN)
-      stack_size = PTHREAD_STACK_MIN;
-#endif
-  }
-
-  if (stack_size > 0) {
-    attr = &attr_storage;
-
-    if (pthread_attr_init(attr))
-      abort();
-
-    if (pthread_attr_setstacksize(attr, stack_size))
-      abort();
-  }
-
-  err = pthread_create(tid, attr, (void*(*)(void*)) (void(*)(void)) entry, arg);
-
-  if (attr != NULL)
-    pthread_attr_destroy(attr);
-
-  return UV__ERR(err);
-}
-
-
-uv_thread_t uv_thread_self(void) {
-  return pthread_self();
-}
-
-int uv_thread_join(uv_thread_t *tid) {
-  return UV__ERR(pthread_join(*tid, NULL));
-}
-
-
-int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2) {
-  return pthread_equal(*t1, *t2);
-}
-
-
-int uv_mutex_init(uv_mutex_t* mutex) {
-#if defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
-  return UV__ERR(pthread_mutex_init(mutex, NULL));
-#else
-  pthread_mutexattr_t attr;
-  int err;
-
-  if (pthread_mutexattr_init(&attr))
-    abort();
-
-  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
-    abort();
-
-  err = pthread_mutex_init(mutex, &attr);
-
-  if (pthread_mutexattr_destroy(&attr))
-    abort();
-
-  return UV__ERR(err);
-#endif
-}
-
-
-int uv_mutex_init_recursive(uv_mutex_t* mutex) {
-  pthread_mutexattr_t attr;
-  int err;
-
-  if (pthread_mutexattr_init(&attr))
-    abort();
-
-  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE))
-    abort();
-
-  err = pthread_mutex_init(mutex, &attr);
-
-  if (pthread_mutexattr_destroy(&attr))
-    abort();
-
-  return UV__ERR(err);
-}
-
-
-void uv_mutex_destroy(uv_mutex_t* mutex) {
-  if (pthread_mutex_destroy(mutex))
-    abort();
-}
-
-
-void uv_mutex_lock(uv_mutex_t* mutex) {
-  if (pthread_mutex_lock(mutex))
-    abort();
-}
-
-
-int uv_mutex_trylock(uv_mutex_t* mutex) {
-  int err;
-
-  err = pthread_mutex_trylock(mutex);
-  if (err) {
-    if (err != EBUSY && err != EAGAIN)
-      abort();
-    return UV_EBUSY;
-  }
-
-  return 0;
-}
-
-
-void uv_mutex_unlock(uv_mutex_t* mutex) {
-  if (pthread_mutex_unlock(mutex))
-    abort();
-}
-
-
-int uv_rwlock_init(uv_rwlock_t* rwlock) {
-  return UV__ERR(pthread_rwlock_init(rwlock, NULL));
-}
-
-
-void uv_rwlock_destroy(uv_rwlock_t* rwlock) {
-  if (pthread_rwlock_destroy(rwlock))
-    abort();
-}
-
-
-void uv_rwlock_rdlock(uv_rwlock_t* rwlock) {
-  if (pthread_rwlock_rdlock(rwlock))
-    abort();
-}
-
-
-int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
-  int err;
-
-  err = pthread_rwlock_tryrdlock(rwlock);
-  if (err) {
-    if (err != EBUSY && err != EAGAIN)
-      abort();
-    return UV_EBUSY;
-  }
-
-  return 0;
-}
-
-
-void uv_rwlock_rdunlock(uv_rwlock_t* rwlock) {
-  if (pthread_rwlock_unlock(rwlock))
-    abort();
-}
-
-
-void uv_rwlock_wrlock(uv_rwlock_t* rwlock) {
-  if (pthread_rwlock_wrlock(rwlock))
-    abort();
-}
-
-
-int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
-  int err;
-
-  err = pthread_rwlock_trywrlock(rwlock);
-  if (err) {
-    if (err != EBUSY && err != EAGAIN)
-      abort();
-    return UV_EBUSY;
-  }
-
-  return 0;
-}
-
-
-void uv_rwlock_wrunlock(uv_rwlock_t* rwlock) {
-  if (pthread_rwlock_unlock(rwlock))
-    abort();
-}
-
-
-void uv_once(uv_once_t* guard, void (*callback)(void)) {
-  if (pthread_once(guard, callback))
-    abort();
-}
-
-#if defined(__APPLE__) && defined(__MACH__)
-
-int uv_sem_init(uv_sem_t* sem, unsigned int value) {
-  kern_return_t err;
-
-  err = semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, value);
-  if (err == KERN_SUCCESS)
-    return 0;
-  if (err == KERN_INVALID_ARGUMENT)
-    return UV_EINVAL;
-  if (err == KERN_RESOURCE_SHORTAGE)
-    return UV_ENOMEM;
-
-  abort();
-  return UV_EINVAL;  /* Satisfy the compiler. */
-}
-
-
-void uv_sem_destroy(uv_sem_t* sem) {
-  if (semaphore_destroy(mach_task_self(), *sem))
-    abort();
-}
-
-
-void uv_sem_post(uv_sem_t* sem) {
-  if (semaphore_signal(*sem))
-    abort();
-}
-
-
-void uv_sem_wait(uv_sem_t* sem) {
-  int r;
-
-  do
-    r = semaphore_wait(*sem);
-  while (r == KERN_ABORTED);
-
-  if (r != KERN_SUCCESS)
-    abort();
-}
-
-
-int uv_sem_trywait(uv_sem_t* sem) {
-  mach_timespec_t interval;
-  kern_return_t err;
-
-  interval.tv_sec = 0;
-  interval.tv_nsec = 0;
-
-  err = semaphore_timedwait(*sem, interval);
-  if (err == KERN_SUCCESS)
-    return 0;
-  if (err == KERN_OPERATION_TIMED_OUT)
-    return UV_EAGAIN;
-
-  abort();
-  return UV_EINVAL;  /* Satisfy the compiler. */
-}
-
-#else /* !(defined(__APPLE__) && defined(__MACH__)) */
-
-#if defined(__GLIBC__) && !defined(__UCLIBC__)
-
-/* Hack around https://sourceware.org/bugzilla/show_bug.cgi?id=12674
- * by providing a custom implementation for glibc < 2.21 in terms of other
- * concurrency primitives.
- * Refs: https://github.com/nodejs/node/issues/19903 */
-
-/* To preserve ABI compatibility, we treat the uv_sem_t as storage for
- * a pointer to the actual struct we're using underneath. */
-
-static uv_once_t glibc_version_check_once = UV_ONCE_INIT;
-static int platform_needs_custom_semaphore = 0;
-
-static void glibc_version_check(void) {
-  const char* version = gnu_get_libc_version();
-  platform_needs_custom_semaphore =
-      version[0] == '2' && version[1] == '.' &&
-      atoi(version + 2) < 21;
-}
-
-#elif defined(__MVS__)
-
-#define platform_needs_custom_semaphore 1
-
-#else /* !defined(__GLIBC__) && !defined(__MVS__) */
-
-#define platform_needs_custom_semaphore 0
-
-#endif
-
-typedef struct uv_semaphore_s {
-  uv_mutex_t mutex;
-  uv_cond_t cond;
-  unsigned int value;
-} uv_semaphore_t;
-
-#if (defined(__GLIBC__) && !defined(__UCLIBC__)) || \
-    platform_needs_custom_semaphore
-STATIC_ASSERT(sizeof(uv_sem_t) >= sizeof(uv_semaphore_t*));
-#endif
-
-static int uv__custom_sem_init(uv_sem_t* sem_, unsigned int value) {
-  int err;
-  uv_semaphore_t* sem;
-
-  sem = (uv_semaphore_t*)uv__malloc(sizeof(*sem));
-  if (sem == NULL)
-    return UV_ENOMEM;
-
-  if ((err = uv_mutex_init(&sem->mutex)) != 0) {
-    uv__free(sem);
-    return err;
-  }
-
-  if ((err = uv_cond_init(&sem->cond)) != 0) {
-    uv_mutex_destroy(&sem->mutex);
-    uv__free(sem);
-    return err;
-  }
-
-  sem->value = value;
-  *(uv_semaphore_t**)sem_ = sem;
-  return 0;
-}
-
-
-static void uv__custom_sem_destroy(uv_sem_t* sem_) {
-  uv_semaphore_t* sem;
-
-  sem = *(uv_semaphore_t**)sem_;
-  uv_cond_destroy(&sem->cond);
-  uv_mutex_destroy(&sem->mutex);
-  uv__free(sem);
-}
-
-
-static void uv__custom_sem_post(uv_sem_t* sem_) {
-  uv_semaphore_t* sem;
-
-  sem = *(uv_semaphore_t**)sem_;
-  uv_mutex_lock(&sem->mutex);
-  sem->value++;
-  if (sem->value == 1)
-    uv_cond_signal(&sem->cond);
-  uv_mutex_unlock(&sem->mutex);
-}
-
-
-static void uv__custom_sem_wait(uv_sem_t* sem_) {
-  uv_semaphore_t* sem;
-
-  sem = *(uv_semaphore_t**)sem_;
-  uv_mutex_lock(&sem->mutex);
-  while (sem->value == 0)
-    uv_cond_wait(&sem->cond, &sem->mutex);
-  sem->value--;
-  uv_mutex_unlock(&sem->mutex);
-}
-
-
-static int uv__custom_sem_trywait(uv_sem_t* sem_) {
-  uv_semaphore_t* sem;
-
-  sem = *(uv_semaphore_t**)sem_;
-  if (uv_mutex_trylock(&sem->mutex) != 0)
-    return UV_EAGAIN;
-
-  if (sem->value == 0) {
-    uv_mutex_unlock(&sem->mutex);
-    return UV_EAGAIN;
-  }
-
-  sem->value--;
-  uv_mutex_unlock(&sem->mutex);
-
-  return 0;
-}
-
-static int uv__sem_init(uv_sem_t* sem, unsigned int value) {
-  if (sem_init(sem, 0, value))
-    return UV__ERR(errno);
-  return 0;
-}
-
-
-static void uv__sem_destroy(uv_sem_t* sem) {
-  if (sem_destroy(sem))
-    abort();
-}
-
-
-static void uv__sem_post(uv_sem_t* sem) {
-  if (sem_post(sem))
-    abort();
-}
-
-
-static void uv__sem_wait(uv_sem_t* sem) {
-  int r;
-
-  do
-    r = sem_wait(sem);
-  while (r == -1 && errno == EINTR);
-
-  if (r)
-    abort();
-}
-
-
-static int uv__sem_trywait(uv_sem_t* sem) {
-  int r;
-
-  do
-    r = sem_trywait(sem);
-  while (r == -1 && errno == EINTR);
-
-  if (r) {
-    if (errno == EAGAIN)
-      return UV_EAGAIN;
-    abort();
-  }
-
-  return 0;
-}
-
-int uv_sem_init(uv_sem_t* sem, unsigned int value) {
-#if defined(__GLIBC__) && !defined(__UCLIBC__)
-  uv_once(&glibc_version_check_once, glibc_version_check);
-#endif
-
-  if (platform_needs_custom_semaphore)
-    return uv__custom_sem_init(sem, value);
-  else
-    return uv__sem_init(sem, value);
-}
-
-
-void uv_sem_destroy(uv_sem_t* sem) {
-  if (platform_needs_custom_semaphore)
-    uv__custom_sem_destroy(sem);
-  else
-    uv__sem_destroy(sem);
-}
-
-
-void uv_sem_post(uv_sem_t* sem) {
-  if (platform_needs_custom_semaphore)
-    uv__custom_sem_post(sem);
-  else
-    uv__sem_post(sem);
-}
-
-
-void uv_sem_wait(uv_sem_t* sem) {
-  if (platform_needs_custom_semaphore)
-    uv__custom_sem_wait(sem);
-  else
-    uv__sem_wait(sem);
-}
-
-
-int uv_sem_trywait(uv_sem_t* sem) {
-  if (platform_needs_custom_semaphore)
-    return uv__custom_sem_trywait(sem);
-  else
-    return uv__sem_trywait(sem);
-}
-
-#endif /* defined(__APPLE__) && defined(__MACH__) */
-
-
-#if defined(__APPLE__) && defined(__MACH__) || defined(__MVS__)
-
-int uv_cond_init(uv_cond_t* cond) {
-  return UV__ERR(pthread_cond_init(cond, NULL));
-}
-
-#else /* !(defined(__APPLE__) && defined(__MACH__)) */
-
-int uv_cond_init(uv_cond_t* cond) {
-  pthread_condattr_t attr;
-  int err;
-
-  err = pthread_condattr_init(&attr);
-  if (err)
-    return UV__ERR(err);
-
-#if !(defined(__ANDROID_API__) && __ANDROID_API__ < 21)
-  err = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
-  if (err)
-    goto error2;
-#endif
-
-  err = pthread_cond_init(cond, &attr);
-  if (err)
-    goto error2;
-
-  err = pthread_condattr_destroy(&attr);
-  if (err)
-    goto error;
-
-  return 0;
-
-error:
-  pthread_cond_destroy(cond);
-error2:
-  pthread_condattr_destroy(&attr);
-  return UV__ERR(err);
-}
-
-#endif /* defined(__APPLE__) && defined(__MACH__) */
-
-void uv_cond_destroy(uv_cond_t* cond) {
-#if defined(__APPLE__) && defined(__MACH__)
-  /* It has been reported that destroying condition variables that have been
-   * signalled but not waited on can sometimes result in application crashes.
-   * See https://codereview.chromium.org/1323293005.
-   */
-  pthread_mutex_t mutex;
-  struct timespec ts;
-  int err;
-
-  if (pthread_mutex_init(&mutex, NULL))
-    abort();
-
-  if (pthread_mutex_lock(&mutex))
-    abort();
-
-  ts.tv_sec = 0;
-  ts.tv_nsec = 1;
-
-  err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
-  if (err != 0 && err != ETIMEDOUT)
-    abort();
-
-  if (pthread_mutex_unlock(&mutex))
-    abort();
-
-  if (pthread_mutex_destroy(&mutex))
-    abort();
-#endif /* defined(__APPLE__) && defined(__MACH__) */
-
-  if (pthread_cond_destroy(cond))
-    abort();
-}
-
-void uv_cond_signal(uv_cond_t* cond) {
-  if (pthread_cond_signal(cond))
-    abort();
-}
-
-void uv_cond_broadcast(uv_cond_t* cond) {
-  if (pthread_cond_broadcast(cond))
-    abort();
-}
-
-void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) {
-  if (pthread_cond_wait(cond, mutex))
-    abort();
-}
-
-
-int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) {
-  int r;
-  struct timespec ts;
-#if defined(__MVS__)
-  struct timeval tv;
-#endif
-
-#if defined(__APPLE__) && defined(__MACH__)
-  ts.tv_sec = timeout / NANOSEC;
-  ts.tv_nsec = timeout % NANOSEC;
-  r = pthread_cond_timedwait_relative_np(cond, mutex, &ts);
-#else
-#if defined(__MVS__)
-  if (gettimeofday(&tv, NULL))
-    abort();
-  timeout += tv.tv_sec * NANOSEC + tv.tv_usec * 1e3;
-#else
-  timeout += uv__hrtime(UV_CLOCK_PRECISE);
-#endif
-  ts.tv_sec = timeout / NANOSEC;
-  ts.tv_nsec = timeout % NANOSEC;
-#if defined(__ANDROID_API__) && __ANDROID_API__ < 21
-
-  /*
-   * The bionic pthread implementation doesn't support CLOCK_MONOTONIC,
-   * but has this alternative function instead.
-   */
-  r = pthread_cond_timedwait_monotonic_np(cond, mutex, &ts);
-#else
-  r = pthread_cond_timedwait(cond, mutex, &ts);
-#endif /* __ANDROID_API__ */
-#endif
-
-
-  if (r == 0)
-    return 0;
-
-  if (r == ETIMEDOUT)
-    return UV_ETIMEDOUT;
-
-  abort();
-#ifndef __SUNPRO_C
-  return UV_EINVAL;  /* Satisfy the compiler. */
-#endif
-}
-
-
-int uv_key_create(uv_key_t* key) {
-  return UV__ERR(pthread_key_create(key, NULL));
-}
-
-
-void uv_key_delete(uv_key_t* key) {
-  if (pthread_key_delete(*key))
-    abort();
-}
-
-
-void* uv_key_get(uv_key_t* key) {
-  return pthread_getspecific(*key);
-}
-
-
-void uv_key_set(uv_key_t* key, void* value) {
-  if (pthread_setspecific(*key, value))
-    abort();
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/tty.cpp b/wpiutil/src/main/native/libuv/src/unix/tty.cpp
deleted file mode 100644
index 5f68140..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/tty.cpp
+++ /dev/null
@@ -1,368 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-#include "spinlock.h"
-
-#include <stdlib.h>
-#include <assert.h>
-#include <unistd.h>
-#include <termios.h>
-#include <errno.h>
-#include <sys/ioctl.h>
-
-#if defined(__MVS__) && !defined(IMAXBEL)
-#define IMAXBEL 0
-#endif
-
-static int orig_termios_fd = -1;
-static struct termios orig_termios;
-static uv_spinlock_t termios_spinlock = UV_SPINLOCK_INITIALIZER;
-
-static int uv__tty_is_peripheral(const int fd) {
-  int result;
-#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-  int dummy;
-
-  result = ioctl(fd, TIOCGPTN, &dummy) != 0;
-#elif defined(__APPLE__)
-  char dummy[256];
-
-  result = ioctl(fd, TIOCPTYGNAME, &dummy) != 0;
-#elif defined(__NetBSD__)
-  /*
-   * NetBSD as an extension returns with ptsname(3) and ptsname_r(3) the
-   * peripheral device name for both descriptors, the controller one and
-   * peripheral one.
-   *
-   * Implement function to compare major device number with pts devices.
-   *
-   * The major numbers are machine-dependent, on NetBSD/amd64 they are
-   * respectively:
-   *  - controller tty: ptc - major 6
-   *  - peripheral tty:  pts - major 5
-   */
-
-  struct stat sb;
-  /* Lookup device's major for the pts driver and cache it. */
-  static devmajor_t pts = NODEVMAJOR;
-
-  if (pts == NODEVMAJOR) {
-    pts = getdevmajor("pts", S_IFCHR);
-    if (pts == NODEVMAJOR)
-      abort();
-  }
-
-  /* Lookup stat structure behind the file descriptor. */
-  if (fstat(fd, &sb) != 0)
-    abort();
-
-  /* Assert character device. */
-  if (!S_ISCHR(sb.st_mode))
-    abort();
-
-  /* Assert valid major. */
-  if (major(sb.st_rdev) == NODEVMAJOR)
-    abort();
-
-  result = (pts == major(sb.st_rdev));
-#else
-  /* Fallback to ptsname
-   */
-  result = ptsname(fd) == NULL;
-#endif
-  return result;
-}
-
-int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int unused) {
-  uv_handle_type type;
-  int flags;
-  int newfd;
-  int r;
-  int saved_flags;
-  int mode;
-  char path[256];
-  (void)unused; /* deprecated parameter is no longer needed */
-
-  /* File descriptors that refer to files cannot be monitored with epoll.
-   * That restriction also applies to character devices like /dev/random
-   * (but obviously not /dev/tty.)
-   */
-  type = uv_guess_handle(fd);
-  if (type == UV_FILE || type == UV_UNKNOWN_HANDLE)
-    return UV_EINVAL;
-
-  flags = 0;
-  newfd = -1;
-
-  /* Save the fd flags in case we need to restore them due to an error. */
-  do
-    saved_flags = fcntl(fd, F_GETFL);
-  while (saved_flags == -1 && errno == EINTR);
-
-  if (saved_flags == -1)
-    return UV__ERR(errno);
-  mode = saved_flags & O_ACCMODE;
-
-  /* Reopen the file descriptor when it refers to a tty. This lets us put the
-   * tty in non-blocking mode without affecting other processes that share it
-   * with us.
-   *
-   * Example: `node | cat` - if we put our fd 0 in non-blocking mode, it also
-   * affects fd 1 of `cat` because both file descriptors refer to the same
-   * struct file in the kernel. When we reopen our fd 0, it points to a
-   * different struct file, hence changing its properties doesn't affect
-   * other processes.
-   */
-  if (type == UV_TTY) {
-    /* Reopening a pty in controller mode won't work either because the reopened
-     * pty will be in peripheral mode (*BSD) or reopening will allocate a new
-     * controller/peripheral pair (Linux). Therefore check if the fd points to a
-     * peripheral device.
-     */
-    if (uv__tty_is_peripheral(fd) && ttyname_r(fd, path, sizeof(path)) == 0)
-      r = uv__open_cloexec(path, mode);
-    else
-      r = -1;
-
-    if (r < 0) {
-      /* fallback to using blocking writes */
-      if (mode != O_RDONLY)
-        flags |= UV_HANDLE_BLOCKING_WRITES;
-      goto skip;
-    }
-
-    newfd = r;
-
-    r = uv__dup2_cloexec(newfd, fd);
-    if (r < 0 && r != UV_EINVAL) {
-      /* EINVAL means newfd == fd which could conceivably happen if another
-       * thread called close(fd) between our calls to isatty() and open().
-       * That's a rather unlikely event but let's handle it anyway.
-       */
-      uv__close(newfd);
-      return r;
-    }
-
-    fd = newfd;
-  }
-
-skip:
-  uv__stream_init(loop, (uv_stream_t*) tty, UV_TTY);
-
-  /* If anything fails beyond this point we need to remove the handle from
-   * the handle queue, since it was added by uv__handle_init in uv_stream_init.
-   */
-
-  if (!(flags & UV_HANDLE_BLOCKING_WRITES))
-    uv__nonblock(fd, 1);
-
-#if defined(__APPLE__)
-  r = uv__stream_try_select((uv_stream_t*) tty, &fd);
-  if (r) {
-    int rc = r;
-    if (newfd != -1)
-      uv__close(newfd);
-    QUEUE_REMOVE(&tty->handle_queue);
-    do
-      r = fcntl(fd, F_SETFL, saved_flags);
-    while (r == -1 && errno == EINTR);
-    return rc;
-  }
-#endif
-
-  if (mode != O_WRONLY)
-    flags |= UV_HANDLE_READABLE;
-  if (mode != O_RDONLY)
-    flags |= UV_HANDLE_WRITABLE;
-
-  uv__stream_open((uv_stream_t*) tty, fd, flags);
-  tty->mode = UV_TTY_MODE_NORMAL;
-
-  return 0;
-}
-
-static void uv__tty_make_raw(struct termios* tio) {
-  assert(tio != NULL);
-
-#if defined __sun || defined __MVS__
-  /*
-   * This implementation of cfmakeraw for Solaris and derivatives is taken from
-   * http://www.perkin.org.uk/posts/solaris-portability-cfmakeraw.html.
-   */
-  tio->c_iflag &= ~(IMAXBEL | IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
-                    IGNCR | ICRNL | IXON);
-  tio->c_oflag &= ~OPOST;
-  tio->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-  tio->c_cflag &= ~(CSIZE | PARENB);
-  tio->c_cflag |= CS8;
-#else
-  cfmakeraw(tio);
-#endif /* #ifdef __sun */
-}
-
-int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) {
-  struct termios tmp;
-  int fd;
-
-  if (tty->mode == (int) mode)
-    return 0;
-
-  fd = uv__stream_fd(tty);
-  if (tty->mode == UV_TTY_MODE_NORMAL && mode != UV_TTY_MODE_NORMAL) {
-    if (tcgetattr(fd, &tty->orig_termios))
-      return UV__ERR(errno);
-
-    /* This is used for uv_tty_reset_mode() */
-    uv_spinlock_lock(&termios_spinlock);
-    if (orig_termios_fd == -1) {
-      orig_termios = tty->orig_termios;
-      orig_termios_fd = fd;
-    }
-    uv_spinlock_unlock(&termios_spinlock);
-  }
-
-  tmp = tty->orig_termios;
-  switch (mode) {
-    case UV_TTY_MODE_NORMAL:
-      break;
-    case UV_TTY_MODE_RAW:
-      tmp.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
-      tmp.c_oflag |= (ONLCR);
-      tmp.c_cflag |= (CS8);
-      tmp.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
-      tmp.c_cc[VMIN] = 1;
-      tmp.c_cc[VTIME] = 0;
-      break;
-    case UV_TTY_MODE_IO:
-      uv__tty_make_raw(&tmp);
-      break;
-  }
-
-  /* Apply changes after draining */
-  if (tcsetattr(fd, TCSADRAIN, &tmp))
-    return UV__ERR(errno);
-
-  tty->mode = mode;
-  return 0;
-}
-
-
-int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
-  struct winsize ws;
-  int err;
-
-  do
-    err = ioctl(uv__stream_fd(tty), TIOCGWINSZ, &ws);
-  while (err == -1 && errno == EINTR);
-
-  if (err == -1)
-    return UV__ERR(errno);
-
-  *width = ws.ws_col;
-  *height = ws.ws_row;
-
-  return 0;
-}
-
-
-uv_handle_type uv_guess_handle(uv_file file) {
-  struct sockaddr sa;
-  struct stat s;
-  socklen_t len;
-  int type;
-
-  if (file < 0)
-    return UV_UNKNOWN_HANDLE;
-
-  if (isatty(file))
-    return UV_TTY;
-
-  if (fstat(file, &s))
-    return UV_UNKNOWN_HANDLE;
-
-  if (S_ISREG(s.st_mode))
-    return UV_FILE;
-
-  if (S_ISCHR(s.st_mode))
-    return UV_FILE;  /* XXX UV_NAMED_PIPE? */
-
-  if (S_ISFIFO(s.st_mode))
-    return UV_NAMED_PIPE;
-
-  if (!S_ISSOCK(s.st_mode))
-    return UV_UNKNOWN_HANDLE;
-
-  len = sizeof(type);
-  if (getsockopt(file, SOL_SOCKET, SO_TYPE, &type, &len))
-    return UV_UNKNOWN_HANDLE;
-
-  len = sizeof(sa);
-  if (getsockname(file, &sa, &len))
-    return UV_UNKNOWN_HANDLE;
-
-  if (type == SOCK_DGRAM)
-    if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6)
-      return UV_UDP;
-
-  if (type == SOCK_STREAM) {
-#if defined(_AIX) || defined(__DragonFly__)
-    /* on AIX/DragonFly the getsockname call returns an empty sa structure
-     * for sockets of type AF_UNIX.  For all other types it will
-     * return a properly filled in structure.
-     */
-    if (len == 0)
-      return UV_NAMED_PIPE;
-#endif /* defined(_AIX) || defined(__DragonFly__) */
-
-    if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6)
-      return UV_TCP;
-    if (sa.sa_family == AF_UNIX)
-      return UV_NAMED_PIPE;
-  }
-
-  return UV_UNKNOWN_HANDLE;
-}
-
-
-/* This function is async signal-safe, meaning that it's safe to call from
- * inside a signal handler _unless_ execution was inside uv_tty_set_mode()'s
- * critical section when the signal was raised.
- */
-int uv_tty_reset_mode(void) {
-  int saved_errno;
-  int err;
-
-  saved_errno = errno;
-  if (!uv_spinlock_trylock(&termios_spinlock))
-    return UV_EBUSY;  /* In uv_tty_set_mode(). */
-
-  err = 0;
-  if (orig_termios_fd != -1)
-    if (tcsetattr(orig_termios_fd, TCSANOW, &orig_termios))
-      err = UV__ERR(errno);
-
-  uv_spinlock_unlock(&termios_spinlock);
-  errno = saved_errno;
-
-  return err;
-}
diff --git a/wpiutil/src/main/native/libuv/src/unix/udp.cpp b/wpiutil/src/main/native/libuv/src/unix/udp.cpp
deleted file mode 100644
index 5c03ae1..0000000
--- a/wpiutil/src/main/native/libuv/src/unix/udp.cpp
+++ /dev/null
@@ -1,999 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-#include <assert.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <unistd.h>
-#if defined(__MVS__)
-#include <xti.h>
-#endif
-#include <sys/un.h>
-
-#if defined(IPV6_JOIN_GROUP) && !defined(IPV6_ADD_MEMBERSHIP)
-# define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
-#endif
-
-#if defined(IPV6_LEAVE_GROUP) && !defined(IPV6_DROP_MEMBERSHIP)
-# define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
-#endif
-
-
-static void uv__udp_run_completed(uv_udp_t* handle);
-static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents);
-static void uv__udp_recvmsg(uv_udp_t* handle);
-static void uv__udp_sendmsg(uv_udp_t* handle);
-static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
-                                       int domain,
-                                       unsigned int flags);
-
-
-void uv__udp_close(uv_udp_t* handle) {
-  uv__io_close(handle->loop, &handle->io_watcher);
-  uv__handle_stop(handle);
-
-  if (handle->io_watcher.fd != -1) {
-    uv__close(handle->io_watcher.fd);
-    handle->io_watcher.fd = -1;
-  }
-}
-
-
-void uv__udp_finish_close(uv_udp_t* handle) {
-  uv_udp_send_t* req;
-  QUEUE* q;
-
-  assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
-  assert(handle->io_watcher.fd == -1);
-
-  while (!QUEUE_EMPTY(&handle->write_queue)) {
-    q = QUEUE_HEAD(&handle->write_queue);
-    QUEUE_REMOVE(q);
-
-    req = QUEUE_DATA(q, uv_udp_send_t, queue);
-    req->status = UV_ECANCELED;
-    QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
-  }
-
-  uv__udp_run_completed(handle);
-
-  assert(handle->send_queue_size == 0);
-  assert(handle->send_queue_count == 0);
-
-  /* Now tear down the handle. */
-  handle->recv_cb = NULL;
-  handle->alloc_cb = NULL;
-  /* but _do not_ touch close_cb */
-}
-
-
-static void uv__udp_run_completed(uv_udp_t* handle) {
-  uv_udp_send_t* req;
-  QUEUE* q;
-
-  assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
-  handle->flags |= UV_HANDLE_UDP_PROCESSING;
-
-  while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
-    q = QUEUE_HEAD(&handle->write_completed_queue);
-    QUEUE_REMOVE(q);
-
-    req = QUEUE_DATA(q, uv_udp_send_t, queue);
-    uv__req_unregister(handle->loop, req);
-
-    handle->send_queue_size -= uv__count_bufs(req->bufs, req->nbufs);
-    handle->send_queue_count--;
-
-    if (req->bufs != req->bufsml)
-      uv__free(req->bufs);
-    req->bufs = NULL;
-
-    if (req->send_cb == NULL)
-      continue;
-
-    /* req->status >= 0 == bytes written
-     * req->status <  0 == errno
-     */
-    if (req->status >= 0)
-      req->send_cb(req, 0);
-    else
-      req->send_cb(req, req->status);
-  }
-
-  if (QUEUE_EMPTY(&handle->write_queue)) {
-    /* Pending queue and completion queue empty, stop watcher. */
-    uv__io_stop(handle->loop, &handle->io_watcher, POLLOUT);
-    if (!uv__io_active(&handle->io_watcher, POLLIN))
-      uv__handle_stop(handle);
-  }
-
-  handle->flags &= ~UV_HANDLE_UDP_PROCESSING;
-}
-
-
-static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents) {
-  uv_udp_t* handle;
-
-  handle = container_of(w, uv_udp_t, io_watcher);
-  assert(handle->type == UV_UDP);
-
-  if (revents & POLLIN)
-    uv__udp_recvmsg(handle);
-
-  if (revents & POLLOUT) {
-    uv__udp_sendmsg(handle);
-    uv__udp_run_completed(handle);
-  }
-}
-
-
-static void uv__udp_recvmsg(uv_udp_t* handle) {
-  struct sockaddr_storage peer;
-  struct msghdr h;
-  ssize_t nread;
-  uv_buf_t buf;
-  int flags;
-  int count;
-
-  assert(handle->recv_cb != NULL);
-  assert(handle->alloc_cb != NULL);
-
-  /* Prevent loop starvation when the data comes in as fast as (or faster than)
-   * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
-   */
-  count = 32;
-
-  memset(&h, 0, sizeof(h));
-  h.msg_name = &peer;
-
-  do {
-    buf = uv_buf_init(NULL, 0);
-    handle->alloc_cb((uv_handle_t*) handle, 64 * 1024, &buf);
-    if (buf.base == NULL || buf.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
-      return;
-    }
-    assert(buf.base != NULL);
-
-    h.msg_namelen = sizeof(peer);
-    h.msg_iov = (iovec*) &buf;
-    h.msg_iovlen = 1;
-
-    do {
-      nread = recvmsg(handle->io_watcher.fd, &h, 0);
-    }
-    while (nread == -1 && errno == EINTR);
-
-    if (nread == -1) {
-      if (errno == EAGAIN || errno == EWOULDBLOCK)
-        handle->recv_cb(handle, 0, &buf, NULL, 0);
-      else
-        handle->recv_cb(handle, UV__ERR(errno), &buf, NULL, 0);
-    }
-    else {
-      const struct sockaddr *addr;
-      if (h.msg_namelen == 0)
-        addr = NULL;
-      else
-        addr = (const struct sockaddr*) &peer;
-
-      flags = 0;
-      if (h.msg_flags & MSG_TRUNC)
-        flags |= UV_UDP_PARTIAL;
-
-      handle->recv_cb(handle, nread, &buf, addr, flags);
-    }
-  }
-  /* recv_cb callback may decide to pause or close the handle */
-  while (nread != -1
-      && count-- > 0
-      && handle->io_watcher.fd != -1
-      && handle->recv_cb != NULL);
-}
-
-
-static void uv__udp_sendmsg(uv_udp_t* handle) {
-  uv_udp_send_t* req;
-  QUEUE* q;
-  struct msghdr h;
-  ssize_t size;
-
-  while (!QUEUE_EMPTY(&handle->write_queue)) {
-    q = QUEUE_HEAD(&handle->write_queue);
-    assert(q != NULL);
-
-    req = QUEUE_DATA(q, uv_udp_send_t, queue);
-    assert(req != NULL);
-
-    memset(&h, 0, sizeof h);
-    if (req->addr.ss_family == AF_UNSPEC) {
-      h.msg_name = NULL;
-      h.msg_namelen = 0;
-    } else {
-      h.msg_name = &req->addr;
-      if (req->addr.ss_family == AF_INET6)
-        h.msg_namelen = sizeof(struct sockaddr_in6);
-      else if (req->addr.ss_family == AF_INET)
-        h.msg_namelen = sizeof(struct sockaddr_in);
-      else if (req->addr.ss_family == AF_UNIX)
-        h.msg_namelen = sizeof(struct sockaddr_un);
-      else {
-        assert(0 && "unsupported address family");
-        abort();
-      }
-    }
-    h.msg_iov = (struct iovec*) req->bufs;
-    h.msg_iovlen = req->nbufs;
-
-    do {
-      size = sendmsg(handle->io_watcher.fd, &h, 0);
-    } while (size == -1 && errno == EINTR);
-
-    if (size == -1) {
-      if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
-        break;
-    }
-
-    req->status = (size == -1 ? UV__ERR(errno) : size);
-
-    /* Sending a datagram is an atomic operation: either all data
-     * is written or nothing is (and EMSGSIZE is raised). That is
-     * why we don't handle partial writes. Just pop the request
-     * off the write queue and onto the completed queue, done.
-     */
-    QUEUE_REMOVE(&req->queue);
-    QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
-    uv__io_feed(handle->loop, &handle->io_watcher);
-  }
-}
-
-
-/* On the BSDs, SO_REUSEPORT implies SO_REUSEADDR but with some additional
- * refinements for programs that use multicast.
- *
- * Linux as of 3.9 has a SO_REUSEPORT socket option but with semantics that
- * are different from the BSDs: it _shares_ the port rather than steal it
- * from the current listener.  While useful, it's not something we can emulate
- * on other platforms so we don't enable it.
- *
- * zOS does not support getsockname with SO_REUSEPORT option when using
- * AF_UNIX.
- */
-static int uv__set_reuse(int fd) {
-  int yes;
-  yes = 1;
-
-#if defined(SO_REUSEPORT) && defined(__MVS__)
-  struct sockaddr_in sockfd;
-  unsigned int sockfd_len = sizeof(sockfd);
-  if (getsockname(fd, (struct sockaddr*) &sockfd, &sockfd_len) == -1)
-      return UV__ERR(errno);
-  if (sockfd.sin_family == AF_UNIX) {
-    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)))
-      return UV__ERR(errno);
-  } else {
-    if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes)))
-       return UV__ERR(errno);
-  }
-#elif defined(SO_REUSEPORT) && !defined(__linux__)
-  if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes)))
-    return UV__ERR(errno);
-#else
-  if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)))
-    return UV__ERR(errno);
-#endif
-
-  return 0;
-}
-
-
-int uv__udp_bind(uv_udp_t* handle,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 unsigned int flags) {
-  int err;
-  int yes;
-  int fd;
-
-  /* Check for bad flags. */
-  if (flags & ~(UV_UDP_IPV6ONLY | UV_UDP_REUSEADDR))
-    return UV_EINVAL;
-
-  /* Cannot set IPv6-only mode on non-IPv6 socket. */
-  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6)
-    return UV_EINVAL;
-
-  fd = handle->io_watcher.fd;
-  if (fd == -1) {
-    err = uv__socket(addr->sa_family, SOCK_DGRAM, 0);
-    if (err < 0)
-      return err;
-    fd = err;
-    handle->io_watcher.fd = fd;
-  }
-
-  if (flags & UV_UDP_REUSEADDR) {
-    err = uv__set_reuse(fd);
-    if (err)
-      return err;
-  }
-
-  if (flags & UV_UDP_IPV6ONLY) {
-#ifdef IPV6_V6ONLY
-    yes = 1;
-    if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof yes) == -1) {
-      err = UV__ERR(errno);
-      return err;
-    }
-#else
-    err = UV_ENOTSUP;
-    return err;
-#endif
-  }
-
-  if (bind(fd, addr, addrlen)) {
-    err = UV__ERR(errno);
-    if (errno == EAFNOSUPPORT)
-      /* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
-       * socket created with AF_INET to an AF_INET6 address or vice versa. */
-      err = UV_EINVAL;
-    return err;
-  }
-
-  if (addr->sa_family == AF_INET6)
-    handle->flags |= UV_HANDLE_IPV6;
-
-  handle->flags |= UV_HANDLE_BOUND;
-  return 0;
-}
-
-
-static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
-                                       int domain,
-                                       unsigned int flags) {
-  union {
-    struct sockaddr_in6 in6;
-    struct sockaddr_in in;
-    struct sockaddr addr;
-  } taddr;
-  socklen_t addrlen;
-
-  if (handle->io_watcher.fd != -1)
-    return 0;
-
-  switch (domain) {
-  case AF_INET:
-  {
-    struct sockaddr_in* addr = &taddr.in;
-    memset(addr, 0, sizeof *addr);
-    addr->sin_family = AF_INET;
-    addr->sin_addr.s_addr = INADDR_ANY;
-    addrlen = sizeof *addr;
-    break;
-  }
-  case AF_INET6:
-  {
-    struct sockaddr_in6* addr = &taddr.in6;
-    memset(addr, 0, sizeof *addr);
-    addr->sin6_family = AF_INET6;
-    addr->sin6_addr = in6addr_any;
-    addrlen = sizeof *addr;
-    break;
-  }
-  default:
-    assert(0 && "unsupported address family");
-    abort();
-  }
-
-  return uv__udp_bind(handle, &taddr.addr, addrlen, flags);
-}
-
-
-int uv__udp_connect(uv_udp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen) {
-  int err;
-
-  err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
-  if (err)
-    return err;
-
-  do {
-    errno = 0;
-    err = connect(handle->io_watcher.fd, addr, addrlen);
-  } while (err == -1 && errno == EINTR);
-
-  if (err)
-    return UV__ERR(errno);
-
-  handle->flags |= UV_HANDLE_UDP_CONNECTED;
-
-  return 0;
-}
-
-
-int uv__udp_disconnect(uv_udp_t* handle) {
-    int r;
-    struct sockaddr addr;
-
-    memset(&addr, 0, sizeof(addr));
-
-    addr.sa_family = AF_UNSPEC;
-
-    do {
-      errno = 0;
-      r = connect(handle->io_watcher.fd, &addr, sizeof(addr));
-    } while (r == -1 && errno == EINTR);
-
-    if (r == -1 && errno != EAFNOSUPPORT)
-      return UV__ERR(errno);
-
-    handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
-    return 0;
-}
-
-
-int uv__udp_send(uv_udp_send_t* req,
-                 uv_udp_t* handle,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 uv_udp_send_cb send_cb) {
-  int err;
-  int empty_queue;
-
-  assert(nbufs > 0);
-
-  if (addr) {
-    err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
-    if (err)
-      return err;
-  }
-
-  /* It's legal for send_queue_count > 0 even when the write_queue is empty;
-   * it means there are error-state requests in the write_completed_queue that
-   * will touch up send_queue_size/count later.
-   */
-  empty_queue = (handle->send_queue_count == 0);
-
-  uv__req_init(handle->loop, req, UV_UDP_SEND);
-  assert(addrlen <= sizeof(req->addr));
-  if (addr == NULL)
-    req->addr.ss_family = AF_UNSPEC;
-  else
-    memcpy(&req->addr, addr, addrlen);
-  req->send_cb = send_cb;
-  req->handle = handle;
-  req->nbufs = nbufs;
-
-  req->bufs = req->bufsml;
-  if (nbufs > ARRAY_SIZE(req->bufsml))
-    req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(bufs[0]));
-
-  if (req->bufs == NULL) {
-    uv__req_unregister(handle->loop, req);
-    return UV_ENOMEM;
-  }
-
-  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
-  handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);
-  handle->send_queue_count++;
-  QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
-  uv__handle_start(handle);
-
-  if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
-    uv__udp_sendmsg(handle);
-
-    /* `uv__udp_sendmsg` may not be able to do non-blocking write straight
-     * away. In such cases the `io_watcher` has to be queued for asynchronous
-     * write.
-     */
-    if (!QUEUE_EMPTY(&handle->write_queue))
-      uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
-  } else {
-    uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
-  }
-
-  return 0;
-}
-
-
-int uv__udp_try_send(uv_udp_t* handle,
-                     const uv_buf_t bufs[],
-                     unsigned int nbufs,
-                     const struct sockaddr* addr,
-                     unsigned int addrlen) {
-  int err;
-  struct msghdr h;
-  ssize_t size;
-
-  assert(nbufs > 0);
-
-  /* already sending a message */
-  if (handle->send_queue_count != 0)
-    return UV_EAGAIN;
-
-  if (addr) {
-    err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
-    if (err)
-      return err;
-  } else {
-    assert(handle->flags & UV_HANDLE_UDP_CONNECTED);
-  }
-
-  memset(&h, 0, sizeof h);
-  h.msg_name = (struct sockaddr*) addr;
-  h.msg_namelen = addrlen;
-  h.msg_iov = (struct iovec*) bufs;
-  h.msg_iovlen = nbufs;
-
-  do {
-    size = sendmsg(handle->io_watcher.fd, &h, 0);
-  } while (size == -1 && errno == EINTR);
-
-  if (size == -1) {
-    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
-      return UV_EAGAIN;
-    else
-      return UV__ERR(errno);
-  }
-
-  return size;
-}
-
-
-static int uv__udp_set_membership4(uv_udp_t* handle,
-                                   const struct sockaddr_in* multicast_addr,
-                                   const char* interface_addr,
-                                   uv_membership membership) {
-  struct ip_mreq mreq;
-  int optname;
-  int err;
-
-  memset(&mreq, 0, sizeof mreq);
-
-  if (interface_addr) {
-    err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
-    if (err)
-      return err;
-  } else {
-    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
-  }
-
-  mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
-
-  switch (membership) {
-  case UV_JOIN_GROUP:
-    optname = IP_ADD_MEMBERSHIP;
-    break;
-  case UV_LEAVE_GROUP:
-    optname = IP_DROP_MEMBERSHIP;
-    break;
-  default:
-    return UV_EINVAL;
-  }
-
-  if (setsockopt(handle->io_watcher.fd,
-                 IPPROTO_IP,
-                 optname,
-                 &mreq,
-                 sizeof(mreq))) {
-#if defined(__MVS__)
-  if (errno == ENXIO)
-    return UV_ENODEV;
-#endif
-    return UV__ERR(errno);
-  }
-
-  return 0;
-}
-
-
-static int uv__udp_set_membership6(uv_udp_t* handle,
-                                   const struct sockaddr_in6* multicast_addr,
-                                   const char* interface_addr,
-                                   uv_membership membership) {
-  int optname;
-  struct ipv6_mreq mreq;
-  struct sockaddr_in6 addr6;
-
-  memset(&mreq, 0, sizeof mreq);
-
-  if (interface_addr) {
-    if (uv_ip6_addr(interface_addr, 0, &addr6))
-      return UV_EINVAL;
-    mreq.ipv6mr_interface = addr6.sin6_scope_id;
-  } else {
-    mreq.ipv6mr_interface = 0;
-  }
-
-  mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;
-
-  switch (membership) {
-  case UV_JOIN_GROUP:
-    optname = IPV6_ADD_MEMBERSHIP;
-    break;
-  case UV_LEAVE_GROUP:
-    optname = IPV6_DROP_MEMBERSHIP;
-    break;
-  default:
-    return UV_EINVAL;
-  }
-
-  if (setsockopt(handle->io_watcher.fd,
-                 IPPROTO_IPV6,
-                 optname,
-                 &mreq,
-                 sizeof(mreq))) {
-#if defined(__MVS__)
-  if (errno == ENXIO)
-    return UV_ENODEV;
-#endif
-    return UV__ERR(errno);
-  }
-
-  return 0;
-}
-
-
-int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags) {
-  int domain;
-  int err;
-  int fd;
-
-  /* Use the lower 8 bits for the domain */
-  domain = flags & 0xFF;
-  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
-    return UV_EINVAL;
-
-  if (flags & ~0xFF)
-    return UV_EINVAL;
-
-  if (domain != AF_UNSPEC) {
-    err = uv__socket(domain, SOCK_DGRAM, 0);
-    if (err < 0)
-      return err;
-    fd = err;
-  } else {
-    fd = -1;
-  }
-
-  uv__handle_init(loop, (uv_handle_t*)handle, UV_UDP);
-  handle->alloc_cb = NULL;
-  handle->recv_cb = NULL;
-  handle->send_queue_size = 0;
-  handle->send_queue_count = 0;
-  uv__io_init(&handle->io_watcher, uv__udp_io, fd);
-  QUEUE_INIT(&handle->write_queue);
-  QUEUE_INIT(&handle->write_completed_queue);
-
-  return 0;
-}
-
-
-int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle) {
-  return uv_udp_init_ex(loop, handle, AF_UNSPEC);
-}
-
-
-int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
-  int err;
-
-  /* Check for already active socket. */
-  if (handle->io_watcher.fd != -1)
-    return UV_EBUSY;
-
-  if (uv__fd_exists(handle->loop, sock))
-    return UV_EEXIST;
-
-  err = uv__nonblock(sock, 1);
-  if (err)
-    return err;
-
-  err = uv__set_reuse(sock);
-  if (err)
-    return err;
-
-  handle->io_watcher.fd = sock;
-  if (uv__udp_is_connected(handle))
-    handle->flags |= UV_HANDLE_UDP_CONNECTED;
-
-  return 0;
-}
-
-
-int uv_udp_set_membership(uv_udp_t* handle,
-                          const char* multicast_addr,
-                          const char* interface_addr,
-                          uv_membership membership) {
-  int err;
-  struct sockaddr_in addr4;
-  struct sockaddr_in6 addr6;
-
-  if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0) {
-    err = uv__udp_maybe_deferred_bind(handle, AF_INET, UV_UDP_REUSEADDR);
-    if (err)
-      return err;
-    return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
-  } else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0) {
-    err = uv__udp_maybe_deferred_bind(handle, AF_INET6, UV_UDP_REUSEADDR);
-    if (err)
-      return err;
-    return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
-  } else {
-    return UV_EINVAL;
-  }
-}
-
-static int uv__setsockopt(uv_udp_t* handle,
-                         int option4,
-                         int option6,
-                         const void* val,
-                         size_t size) {
-  int r;
-
-  if (handle->flags & UV_HANDLE_IPV6)
-    r = setsockopt(handle->io_watcher.fd,
-                   IPPROTO_IPV6,
-                   option6,
-                   val,
-                   size);
-  else
-    r = setsockopt(handle->io_watcher.fd,
-                   IPPROTO_IP,
-                   option4,
-                   val,
-                   size);
-  if (r)
-    return UV__ERR(errno);
-
-  return 0;
-}
-
-static int uv__setsockopt_maybe_char(uv_udp_t* handle,
-                                     int option4,
-                                     int option6,
-                                     int val) {
-#if defined(__sun) || defined(_AIX) || defined(__MVS__)
-  char arg = val;
-#elif defined(__OpenBSD__)
-  unsigned char arg = val;
-#else
-  int arg = val;
-#endif
-
-  if (val < 0 || val > 255)
-    return UV_EINVAL;
-
-  return uv__setsockopt(handle, option4, option6, &arg, sizeof(arg));
-}
-
-
-int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
-  if (setsockopt(handle->io_watcher.fd,
-                 SOL_SOCKET,
-                 SO_BROADCAST,
-                 &on,
-                 sizeof(on))) {
-    return UV__ERR(errno);
-  }
-
-  return 0;
-}
-
-
-int uv_udp_set_ttl(uv_udp_t* handle, int ttl) {
-  if (ttl < 1 || ttl > 255)
-    return UV_EINVAL;
-
-#if defined(__MVS__)
-  if (!(handle->flags & UV_HANDLE_IPV6))
-    return UV_ENOTSUP;  /* zOS does not support setting ttl for IPv4 */
-#endif
-
-/*
- * On Solaris and derivatives such as SmartOS, the length of socket options
- * is sizeof(int) for IP_TTL and IPV6_UNICAST_HOPS,
- * so hardcode the size of these options on this platform,
- * and use the general uv__setsockopt_maybe_char call on other platforms.
- */
-#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
-    defined(__MVS__)
-
-  return uv__setsockopt(handle,
-                        IP_TTL,
-                        IPV6_UNICAST_HOPS,
-                        &ttl,
-                        sizeof(ttl));
-
-#else /* !(defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
-           defined(__MVS__)) */
-
-  return uv__setsockopt_maybe_char(handle,
-                                   IP_TTL,
-                                   IPV6_UNICAST_HOPS,
-                                   ttl);
-
-#endif /* defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
-          defined(__MVS__) */
-}
-
-
-int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl) {
-/*
- * On Solaris and derivatives such as SmartOS, the length of socket options
- * is sizeof(int) for IPV6_MULTICAST_HOPS and sizeof(char) for
- * IP_MULTICAST_TTL, so hardcode the size of the option in the IPv6 case,
- * and use the general uv__setsockopt_maybe_char call otherwise.
- */
-#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
-    defined(__MVS__)
-  if (handle->flags & UV_HANDLE_IPV6)
-    return uv__setsockopt(handle,
-                          IP_MULTICAST_TTL,
-                          IPV6_MULTICAST_HOPS,
-                          &ttl,
-                          sizeof(ttl));
-#endif /* defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
-    defined(__MVS__) */
-
-  return uv__setsockopt_maybe_char(handle,
-                                   IP_MULTICAST_TTL,
-                                   IPV6_MULTICAST_HOPS,
-                                   ttl);
-}
-
-
-int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) {
-/*
- * On Solaris and derivatives such as SmartOS, the length of socket options
- * is sizeof(int) for IPV6_MULTICAST_LOOP and sizeof(char) for
- * IP_MULTICAST_LOOP, so hardcode the size of the option in the IPv6 case,
- * and use the general uv__setsockopt_maybe_char call otherwise.
- */
-#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
-    defined(__MVS__) 
-  if (handle->flags & UV_HANDLE_IPV6)
-    return uv__setsockopt(handle,
-                          IP_MULTICAST_LOOP,
-                          IPV6_MULTICAST_LOOP,
-                          &on,
-                          sizeof(on));
-#endif /* defined(__sun) || defined(_AIX) ||defined(__OpenBSD__) ||
-    defined(__MVS__) */
-
-  return uv__setsockopt_maybe_char(handle,
-                                   IP_MULTICAST_LOOP,
-                                   IPV6_MULTICAST_LOOP,
-                                   on);
-}
-
-int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
-  struct sockaddr_storage addr_st;
-  struct sockaddr_in* addr4;
-  struct sockaddr_in6* addr6;
-
-  addr4 = (struct sockaddr_in*) &addr_st;
-  addr6 = (struct sockaddr_in6*) &addr_st;
-
-  if (!interface_addr) {
-    memset(&addr_st, 0, sizeof addr_st);
-    if (handle->flags & UV_HANDLE_IPV6) {
-      addr_st.ss_family = AF_INET6;
-      addr6->sin6_scope_id = 0;
-    } else {
-      addr_st.ss_family = AF_INET;
-      addr4->sin_addr.s_addr = htonl(INADDR_ANY);
-    }
-  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
-    /* nothing, address was parsed */
-  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
-    /* nothing, address was parsed */
-  } else {
-    return UV_EINVAL;
-  }
-
-  if (addr_st.ss_family == AF_INET) {
-    if (setsockopt(handle->io_watcher.fd,
-                   IPPROTO_IP,
-                   IP_MULTICAST_IF,
-                   (void*) &addr4->sin_addr,
-                   sizeof(addr4->sin_addr)) == -1) {
-      return UV__ERR(errno);
-    }
-  } else if (addr_st.ss_family == AF_INET6) {
-    if (setsockopt(handle->io_watcher.fd,
-                   IPPROTO_IPV6,
-                   IPV6_MULTICAST_IF,
-                   &addr6->sin6_scope_id,
-                   sizeof(addr6->sin6_scope_id)) == -1) {
-      return UV__ERR(errno);
-    }
-  } else {
-    assert(0 && "unexpected address family");
-    abort();
-  }
-
-  return 0;
-}
-
-int uv_udp_getpeername(const uv_udp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getpeername,
-                             name,
-                             namelen);
-}
-
-int uv_udp_getsockname(const uv_udp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getsockname,
-                             name,
-                             namelen);
-}
-
-
-int uv__udp_recv_start(uv_udp_t* handle,
-                       uv_alloc_cb alloc_cb,
-                       uv_udp_recv_cb recv_cb) {
-  int err;
-
-  if (alloc_cb == NULL || recv_cb == NULL)
-    return UV_EINVAL;
-
-  if (uv__io_active(&handle->io_watcher, POLLIN))
-    return UV_EALREADY;  /* FIXME(bnoordhuis) Should be UV_EBUSY. */
-
-  err = uv__udp_maybe_deferred_bind(handle, AF_INET, 0);
-  if (err)
-    return err;
-
-  handle->alloc_cb = alloc_cb;
-  handle->recv_cb = recv_cb;
-
-  uv__io_start(handle->loop, &handle->io_watcher, POLLIN);
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-int uv__udp_recv_stop(uv_udp_t* handle) {
-  uv__io_stop(handle->loop, &handle->io_watcher, POLLIN);
-
-  if (!uv__io_active(&handle->io_watcher, POLLOUT))
-    uv__handle_stop(handle);
-
-  handle->alloc_cb = NULL;
-  handle->recv_cb = NULL;
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/uv-common.cpp b/wpiutil/src/main/native/libuv/src/uv-common.cpp
deleted file mode 100644
index 3c65476..0000000
--- a/wpiutil/src/main/native/libuv/src/uv-common.cpp
+++ /dev/null
@@ -1,797 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "uv-common.h"
-
-#include <assert.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <stddef.h> /* NULL */
-#include <stdio.h>
-#include <stdlib.h> /* malloc */
-#include <string.h> /* memset */
-
-#if defined(_WIN32)
-# include <malloc.h> /* malloc */
-#else
-# include <net/if.h> /* if_nametoindex */
-# include <sys/un.h> /* AF_UNIX, sockaddr_un */
-#endif
-
-
-typedef struct {
-  uv_malloc_func local_malloc;
-  uv_realloc_func local_realloc;
-  uv_calloc_func local_calloc;
-  uv_free_func local_free;
-} uv__allocator_t;
-
-static uv__allocator_t uv__allocator = {
-  malloc,
-  realloc,
-  calloc,
-  free,
-};
-
-char* uv__strdup(const char* s) {
-  size_t len = strlen(s) + 1;
-  char* m = (char*)uv__malloc(len);
-  if (m == NULL)
-    return NULL;
-  return (char*)memcpy(m, s, len);
-}
-
-char* uv__strndup(const char* s, size_t n) {
-  char* m;
-  size_t len = strlen(s);
-  if (n < len)
-    len = n;
-  m = (char*)uv__malloc(len + 1);
-  if (m == NULL)
-    return NULL;
-  m[len] = '\0';
-  return (char*)memcpy(m, s, len);
-}
-
-void* uv__malloc(size_t size) {
-  if (size > 0)
-    return uv__allocator.local_malloc(size);
-  return NULL;
-}
-
-void uv__free(void* ptr) {
-  int saved_errno;
-
-  /* Libuv expects that free() does not clobber errno.  The system allocator
-   * honors that assumption but custom allocators may not be so careful.
-   */
-  saved_errno = errno;
-  uv__allocator.local_free(ptr);
-  errno = saved_errno;
-}
-
-void* uv__calloc(size_t count, size_t size) {
-  return uv__allocator.local_calloc(count, size);
-}
-
-void* uv__realloc(void* ptr, size_t size) {
-  if (size > 0)
-    return uv__allocator.local_realloc(ptr, size);
-  uv__free(ptr);
-  return NULL;
-}
-
-int uv_replace_allocator(uv_malloc_func malloc_func,
-                         uv_realloc_func realloc_func,
-                         uv_calloc_func calloc_func,
-                         uv_free_func free_func) {
-  if (malloc_func == NULL || realloc_func == NULL ||
-      calloc_func == NULL || free_func == NULL) {
-    return UV_EINVAL;
-  }
-
-  uv__allocator.local_malloc = malloc_func;
-  uv__allocator.local_realloc = realloc_func;
-  uv__allocator.local_calloc = calloc_func;
-  uv__allocator.local_free = free_func;
-
-  return 0;
-}
-
-#define XX(uc, lc) case UV_##uc: return sizeof(uv_##lc##_t);
-
-size_t uv_handle_size(uv_handle_type type) {
-  switch (type) {
-    UV_HANDLE_TYPE_MAP(XX)
-    default:
-      return -1;
-  }
-}
-
-size_t uv_req_size(uv_req_type type) {
-  switch(type) {
-    UV_REQ_TYPE_MAP(XX)
-    default:
-      return -1;
-  }
-}
-
-#undef XX
-
-
-size_t uv_loop_size(void) {
-  return sizeof(uv_loop_t);
-}
-
-
-uv_buf_t uv_buf_init(char* base, unsigned int len) {
-  uv_buf_t buf;
-  buf.base = base;
-  buf.len = len;
-  return buf;
-}
-
-
-static const char* uv__unknown_err_code(int err) {
-  char buf[32];
-  char* copy;
-
-  snprintf(buf, sizeof(buf), "Unknown system error %d", err);
-  copy = uv__strdup(buf);
-
-  return copy != NULL ? copy : "Unknown system error";
-}
-
-#define UV_ERR_NAME_GEN_R(name, _) \
-case UV_## name: \
-  uv__strscpy(buf, #name, buflen); break;
-char* uv_err_name_r(int err, char* buf, size_t buflen) {
-  switch (err) {
-    UV_ERRNO_MAP(UV_ERR_NAME_GEN_R)
-    default: snprintf(buf, buflen, "Unknown system error %d", err);
-  }
-  return buf;
-}
-#undef UV_ERR_NAME_GEN_R
-
-
-#define UV_ERR_NAME_GEN(name, _) case UV_ ## name: return #name;
-const char* uv_err_name(int err) {
-  switch (err) {
-    UV_ERRNO_MAP(UV_ERR_NAME_GEN)
-  }
-  return uv__unknown_err_code(err);
-}
-#undef UV_ERR_NAME_GEN
-
-
-#define UV_STRERROR_GEN_R(name, msg) \
-case UV_ ## name: \
-  snprintf(buf, buflen, "%s", msg); break;
-char* uv_strerror_r(int err, char* buf, size_t buflen) {
-  switch (err) {
-    UV_ERRNO_MAP(UV_STRERROR_GEN_R)
-    default: snprintf(buf, buflen, "Unknown system error %d", err);
-  }
-  return buf;
-}
-#undef UV_STRERROR_GEN_R
-
-
-#define UV_STRERROR_GEN(name, msg) case UV_ ## name: return msg;
-const char* uv_strerror(int err) {
-  switch (err) {
-    UV_ERRNO_MAP(UV_STRERROR_GEN)
-  }
-  return uv__unknown_err_code(err);
-}
-#undef UV_STRERROR_GEN
-
-
-int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) {
-  memset(addr, 0, sizeof(*addr));
-  addr->sin_family = AF_INET;
-  addr->sin_port = htons(port);
-  return uv_inet_pton(AF_INET, ip, &(addr->sin_addr.s_addr));
-}
-
-
-int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
-  char address_part[40];
-  size_t address_part_size;
-  const char* zone_index;
-
-  memset(addr, 0, sizeof(*addr));
-  addr->sin6_family = AF_INET6;
-  addr->sin6_port = htons(port);
-#ifdef SIN6_LEN
-  addr->sin6_len = sizeof(*addr);
-#endif
-
-  zone_index = strchr(ip, '%');
-  if (zone_index != NULL) {
-    address_part_size = zone_index - ip;
-    if (address_part_size >= sizeof(address_part))
-      address_part_size = sizeof(address_part) - 1;
-
-    memcpy(address_part, ip, address_part_size);
-    address_part[address_part_size] = '\0';
-    ip = address_part;
-
-    zone_index++; /* skip '%' */
-    /* NOTE: unknown interface (id=0) is silently ignored */
-#ifdef _WIN32
-    addr->sin6_scope_id = atoi(zone_index);
-#else
-    addr->sin6_scope_id = if_nametoindex(zone_index);
-#endif
-  }
-
-  return uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
-}
-
-
-int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size) {
-  return uv_inet_ntop(AF_INET, &src->sin_addr, dst, size);
-}
-
-
-int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size) {
-  return uv_inet_ntop(AF_INET6, &src->sin6_addr, dst, size);
-}
-
-
-int uv_tcp_bind(uv_tcp_t* handle,
-                const struct sockaddr* addr,
-                unsigned int flags) {
-  unsigned int addrlen;
-
-  if (handle->type != UV_TCP)
-    return UV_EINVAL;
-
-  if (addr->sa_family == AF_INET)
-    addrlen = sizeof(struct sockaddr_in);
-  else if (addr->sa_family == AF_INET6)
-    addrlen = sizeof(struct sockaddr_in6);
-  else
-    return UV_EINVAL;
-
-  return uv__tcp_bind(handle, addr, addrlen, flags);
-}
-
-
-int uv_udp_bind(uv_udp_t* handle,
-                const struct sockaddr* addr,
-                unsigned int flags) {
-  unsigned int addrlen;
-
-  if (handle->type != UV_UDP)
-    return UV_EINVAL;
-
-  if (addr->sa_family == AF_INET)
-    addrlen = sizeof(struct sockaddr_in);
-  else if (addr->sa_family == AF_INET6)
-    addrlen = sizeof(struct sockaddr_in6);
-  else
-    return UV_EINVAL;
-
-  return uv__udp_bind(handle, addr, addrlen, flags);
-}
-
-
-int uv_tcp_connect(uv_connect_t* req,
-                   uv_tcp_t* handle,
-                   const struct sockaddr* addr,
-                   uv_connect_cb cb) {
-  unsigned int addrlen;
-
-  if (handle->type != UV_TCP)
-    return UV_EINVAL;
-
-  if (addr->sa_family == AF_INET)
-    addrlen = sizeof(struct sockaddr_in);
-  else if (addr->sa_family == AF_INET6)
-    addrlen = sizeof(struct sockaddr_in6);
-  else
-    return UV_EINVAL;
-
-  return uv__tcp_connect(req, handle, addr, addrlen, cb);
-}
-
-
-int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr) {
-  unsigned int addrlen;
-
-  if (handle->type != UV_UDP)
-    return UV_EINVAL;
-
-  /* Disconnect the handle */
-  if (addr == NULL) {
-    if (!(handle->flags & UV_HANDLE_UDP_CONNECTED))
-      return UV_ENOTCONN;
-
-    return uv__udp_disconnect(handle);
-  }
-
-  if (addr->sa_family == AF_INET)
-    addrlen = sizeof(struct sockaddr_in);
-  else if (addr->sa_family == AF_INET6)
-    addrlen = sizeof(struct sockaddr_in6);
-  else
-    return UV_EINVAL;
-
-  if (handle->flags & UV_HANDLE_UDP_CONNECTED)
-    return UV_EISCONN;
-
-  return uv__udp_connect(handle, addr, addrlen);
-}
-
-
-int uv__udp_is_connected(uv_udp_t* handle) {
-  struct sockaddr_storage addr;
-  int addrlen;
-  if (handle->type != UV_UDP)
-    return 0;
-
-  addrlen = sizeof(addr);
-  if (uv_udp_getpeername(handle, (struct sockaddr*) &addr, &addrlen) != 0)
-    return 0;
-
-  return addrlen > 0;
-}
-
-
-int uv__udp_check_before_send(uv_udp_t* handle, const struct sockaddr* addr) {
-  unsigned int addrlen;
-
-  if (handle->type != UV_UDP)
-    return UV_EINVAL;
-
-  if (addr != NULL && (handle->flags & UV_HANDLE_UDP_CONNECTED))
-    return UV_EISCONN;
-
-  if (addr == NULL && !(handle->flags & UV_HANDLE_UDP_CONNECTED))
-    return UV_EDESTADDRREQ;
-
-  if (addr != NULL) {
-    if (addr->sa_family == AF_INET)
-      addrlen = sizeof(struct sockaddr_in);
-    else if (addr->sa_family == AF_INET6)
-      addrlen = sizeof(struct sockaddr_in6);
-#if defined(AF_UNIX) && !defined(_WIN32)
-    else if (addr->sa_family == AF_UNIX)
-      addrlen = sizeof(struct sockaddr_un);
-#endif
-    else
-      return UV_EINVAL;
-  } else {
-    addrlen = 0;
-  }
-
-  return addrlen;
-}
-
-
-int uv_udp_send(uv_udp_send_t* req,
-                uv_udp_t* handle,
-                const uv_buf_t bufs[],
-                unsigned int nbufs,
-                const struct sockaddr* addr,
-                uv_udp_send_cb send_cb) {
-  int addrlen;
-
-  addrlen = uv__udp_check_before_send(handle, addr);
-  if (addrlen < 0)
-    return addrlen;
-
-  return uv__udp_send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
-}
-
-
-int uv_udp_try_send(uv_udp_t* handle,
-                    const uv_buf_t bufs[],
-                    unsigned int nbufs,
-                    const struct sockaddr* addr) {
-  int addrlen;
-
-  addrlen = uv__udp_check_before_send(handle, addr);
-  if (addrlen < 0)
-    return addrlen;
-
-  return uv__udp_try_send(handle, bufs, nbufs, addr, addrlen);
-}
-
-
-int uv_udp_recv_start(uv_udp_t* handle,
-                      uv_alloc_cb alloc_cb,
-                      uv_udp_recv_cb recv_cb) {
-  if (handle->type != UV_UDP || alloc_cb == NULL || recv_cb == NULL)
-    return UV_EINVAL;
-  else
-    return uv__udp_recv_start(handle, alloc_cb, recv_cb);
-}
-
-
-int uv_udp_recv_stop(uv_udp_t* handle) {
-  if (handle->type != UV_UDP)
-    return UV_EINVAL;
-  else
-    return uv__udp_recv_stop(handle);
-}
-
-
-void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
-  QUEUE queue;
-  QUEUE* q;
-  uv_handle_t* h;
-
-  QUEUE_MOVE(&loop->handle_queue, &queue);
-  while (!QUEUE_EMPTY(&queue)) {
-    q = QUEUE_HEAD(&queue);
-    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
-
-    QUEUE_REMOVE(q);
-    QUEUE_INSERT_TAIL(&loop->handle_queue, q);
-
-    if (h->flags & UV_HANDLE_INTERNAL) continue;
-    walk_cb(h, arg);
-  }
-}
-
-
-static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) {
-  const char* type;
-  QUEUE* q;
-  uv_handle_t* h;
-
-  if (loop == NULL)
-    loop = uv_default_loop();
-
-  QUEUE_FOREACH(q, &loop->handle_queue) {
-    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
-
-    if (only_active && !uv__is_active(h))
-      continue;
-
-    switch (h->type) {
-#define X(uc, lc) case UV_##uc: type = #lc; break;
-      UV_HANDLE_TYPE_MAP(X)
-#undef X
-      default: type = "<unknown>";
-    }
-
-    fprintf(stream,
-            "[%c%c%c] %-8s %p\n",
-            "R-"[!(h->flags & UV_HANDLE_REF)],
-            "A-"[!(h->flags & UV_HANDLE_ACTIVE)],
-            "I-"[!(h->flags & UV_HANDLE_INTERNAL)],
-            type,
-            (void*)h);
-  }
-}
-
-
-void uv_print_all_handles(uv_loop_t* loop, FILE* stream) {
-  uv__print_handles(loop, 0, stream);
-}
-
-
-void uv_print_active_handles(uv_loop_t* loop, FILE* stream) {
-  uv__print_handles(loop, 1, stream);
-}
-
-
-void uv_ref(uv_handle_t* handle) {
-  uv__handle_ref(handle);
-}
-
-
-void uv_unref(uv_handle_t* handle) {
-  uv__handle_unref(handle);
-}
-
-
-int uv_has_ref(const uv_handle_t* handle) {
-  return uv__has_ref(handle);
-}
-
-
-void uv_stop(uv_loop_t* loop) {
-  loop->stop_flag = 1;
-}
-
-
-uint64_t uv_now(const uv_loop_t* loop) {
-  return loop->time;
-}
-
-
-
-size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs) {
-  unsigned int i;
-  size_t bytes;
-
-  bytes = 0;
-  for (i = 0; i < nbufs; i++)
-    bytes += (size_t) bufs[i].len;
-
-  return bytes;
-}
-
-int uv_recv_buffer_size(uv_handle_t* handle, int* value) {
-  return uv__socket_sockopt(handle, SO_RCVBUF, value);
-}
-
-int uv_send_buffer_size(uv_handle_t* handle, int *value) {
-  return uv__socket_sockopt(handle, SO_SNDBUF, value);
-}
-
-int uv_fs_event_getpath(uv_fs_event_t* handle, char* buffer, size_t* size) {
-  size_t required_len;
-
-  if (!uv__is_active(handle)) {
-    *size = 0;
-    return UV_EINVAL;
-  }
-
-  required_len = strlen(handle->path);
-  if (required_len >= *size) {
-    *size = required_len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, handle->path, required_len);
-  *size = required_len;
-  buffer[required_len] = '\0';
-
-  return 0;
-}
-
-/* The windows implementation does not have the same structure layout as
- * the unix implementation (nbufs is not directly inside req but is
- * contained in a nested union/struct) so this function locates it.
-*/
-static unsigned int* uv__get_nbufs(uv_fs_t* req) {
-#ifdef _WIN32
-  return &req->fs.info.nbufs;
-#else
-  return &req->nbufs;
-#endif
-}
-
-/* uv_fs_scandir() uses the system allocator to allocate memory on non-Windows
- * systems. So, the memory should be released using free(). On Windows,
- * uv__malloc() is used, so use uv__free() to free memory.
-*/
-#ifdef _WIN32
-# define uv__fs_scandir_free uv__free
-#else
-# define uv__fs_scandir_free free
-#endif
-
-void uv__fs_scandir_cleanup(uv_fs_t* req) {
-  uv__dirent_t** dents;
-
-  unsigned int* nbufs = uv__get_nbufs(req);
-
-  dents = (uv__dirent_t**)(req->ptr);
-  if (*nbufs > 0 && *nbufs != (unsigned int) req->result)
-    (*nbufs)--;
-  for (; *nbufs < (unsigned int) req->result; (*nbufs)++)
-    uv__fs_scandir_free(dents[*nbufs]);
-
-  uv__fs_scandir_free(req->ptr);
-  req->ptr = NULL;
-}
-
-
-int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) {
-  uv__dirent_t** dents;
-  uv__dirent_t* dent;
-  unsigned int* nbufs;
-
-  /* Check to see if req passed */
-  if (req->result < 0)
-    return req->result;
-
-  /* Ptr will be null if req was canceled or no files found */
-  if (!req->ptr)
-    return UV_EOF;
-
-  nbufs = uv__get_nbufs(req);
-  assert(nbufs);
-
-  dents = (uv__dirent_t**)(req->ptr);
-
-  /* Free previous entity */
-  if (*nbufs > 0)
-    uv__fs_scandir_free(dents[*nbufs - 1]);
-
-  /* End was already reached */
-  if (*nbufs == (unsigned int) req->result) {
-    uv__fs_scandir_free(dents);
-    req->ptr = NULL;
-    return UV_EOF;
-  }
-
-  dent = dents[(*nbufs)++];
-
-  ent->name = dent->d_name;
-  ent->type = uv__fs_get_dirent_type(dent);
-
-  return 0;
-}
-
-uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent) {
-  uv_dirent_type_t type;
-
-#ifdef HAVE_DIRENT_TYPES
-  switch (dent->d_type) {
-    case UV__DT_DIR:
-      type = UV_DIRENT_DIR;
-      break;
-    case UV__DT_FILE:
-      type = UV_DIRENT_FILE;
-      break;
-    case UV__DT_LINK:
-      type = UV_DIRENT_LINK;
-      break;
-    case UV__DT_FIFO:
-      type = UV_DIRENT_FIFO;
-      break;
-    case UV__DT_SOCKET:
-      type = UV_DIRENT_SOCKET;
-      break;
-    case UV__DT_CHAR:
-      type = UV_DIRENT_CHAR;
-      break;
-    case UV__DT_BLOCK:
-      type = UV_DIRENT_BLOCK;
-      break;
-    default:
-      type = UV_DIRENT_UNKNOWN;
-  }
-#else
-  type = UV_DIRENT_UNKNOWN;
-#endif
-
-  return type;
-}
-
-void uv__fs_readdir_cleanup(uv_fs_t* req) {
-  uv_dir_t* dir;
-  uv_dirent_t* dirents;
-  int i;
-
-  if (req->ptr == NULL)
-    return;
-
-  dir = (uv_dir_t*)req->ptr;
-  dirents = dir->dirents;
-  req->ptr = NULL;
-
-  if (dirents == NULL)
-    return;
-
-  for (i = 0; i < req->result; ++i) {
-    uv__free((char*) dirents[i].name);
-    dirents[i].name = NULL;
-  }
-}
-
-
-#ifdef __clang__
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wvarargs"
-#endif
-
-int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...) {
-  va_list ap;
-  int err;
-
-  va_start(ap, option);
-  /* Any platform-agnostic options should be handled here. */
-  err = uv__loop_configure(loop, option, ap);
-  va_end(ap);
-
-  return err;
-}
-
-#ifdef __clang__
-# pragma clang diagnostic pop
-#endif
-
-
-static uv_loop_t default_loop_struct;
-static uv_loop_t* default_loop_ptr;
-
-
-uv_loop_t* uv_default_loop(void) {
-  if (default_loop_ptr != NULL)
-    return default_loop_ptr;
-
-  if (uv_loop_init(&default_loop_struct))
-    return NULL;
-
-  default_loop_ptr = &default_loop_struct;
-  return default_loop_ptr;
-}
-
-
-uv_loop_t* uv_loop_new(void) {
-  uv_loop_t* loop;
-
-  loop = (uv_loop_t*)uv__malloc(sizeof(*loop));
-  if (loop == NULL)
-    return NULL;
-
-  if (uv_loop_init(loop)) {
-    uv__free(loop);
-    return NULL;
-  }
-
-  return loop;
-}
-
-
-int uv_loop_close(uv_loop_t* loop) {
-  QUEUE* q;
-  uv_handle_t* h;
-#ifndef NDEBUG
-  void* saved_data;
-#endif
-
-  if (uv__has_active_reqs(loop))
-    return UV_EBUSY;
-
-  QUEUE_FOREACH(q, &loop->handle_queue) {
-    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
-    if (!(h->flags & UV_HANDLE_INTERNAL))
-      return UV_EBUSY;
-  }
-
-  uv__loop_close(loop);
-
-#ifndef NDEBUG
-  saved_data = loop->data;
-  memset(loop, -1, sizeof(*loop));
-  loop->data = saved_data;
-#endif
-  if (loop == default_loop_ptr)
-    default_loop_ptr = NULL;
-
-  return 0;
-}
-
-
-void uv_loop_delete(uv_loop_t* loop) {
-  uv_loop_t* default_loop;
-  int err;
-
-  default_loop = default_loop_ptr;
-
-  err = uv_loop_close(loop);
-  (void) err;    /* Squelch compiler warnings. */
-  assert(err == 0);
-  if (loop != default_loop)
-    uv__free(loop);
-}
diff --git a/wpiutil/src/main/native/libuv/src/uv-common.h b/wpiutil/src/main/native/libuv/src/uv-common.h
deleted file mode 100644
index f788161..0000000
--- a/wpiutil/src/main/native/libuv/src/uv-common.h
+++ /dev/null
@@ -1,326 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-/*
- * This file is private to libuv. It provides common functionality to both
- * Windows and Unix backends.
- */
-
-#ifndef UV_COMMON_H_
-#define UV_COMMON_H_
-
-#include <assert.h>
-#include <stdarg.h>
-#include <stddef.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1600
-# include "uv/stdint-msvc2008.h"
-#else
-# include <stdint.h>
-#endif
-
-#include "uv.h"
-#include "uv/tree.h"
-#include "queue.h"
-#include "strscpy.h"
-
-#if EDOM > 0
-# define UV__ERR(x) (-(x))
-#else
-# define UV__ERR(x) (x)
-#endif
-
-#if !defined(snprintf) && defined(_MSC_VER) && _MSC_VER < 1900
-extern int snprintf(char*, size_t, const char*, ...);
-#endif
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-#define container_of(ptr, type, member) \
-  ((type *) ((char *) (ptr) - offsetof(type, member)))
-
-#define STATIC_ASSERT(expr)                                                   \
-  void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])
-
-/* Handle flags. Some flags are specific to Windows or UNIX. */
-enum {
-  /* Used by all handles. */
-  UV_HANDLE_CLOSING                     = 0x00000001,
-  UV_HANDLE_CLOSED                      = 0x00000002,
-  UV_HANDLE_ACTIVE                      = 0x00000004,
-  UV_HANDLE_REF                         = 0x00000008,
-  UV_HANDLE_INTERNAL                    = 0x00000010,
-  UV_HANDLE_ENDGAME_QUEUED              = 0x00000020,
-
-  /* Used by streams. */
-  UV_HANDLE_LISTENING                   = 0x00000040,
-  UV_HANDLE_CONNECTION                  = 0x00000080,
-  UV_HANDLE_SHUTTING                    = 0x00000100,
-  UV_HANDLE_SHUT                        = 0x00000200,
-  UV_HANDLE_READ_PARTIAL                = 0x00000400,
-  UV_HANDLE_READ_EOF                    = 0x00000800,
-
-  /* Used by streams and UDP handles. */
-  UV_HANDLE_READING                     = 0x00001000,
-  UV_HANDLE_BOUND                       = 0x00002000,
-  UV_HANDLE_READABLE                    = 0x00004000,
-  UV_HANDLE_WRITABLE                    = 0x00008000,
-  UV_HANDLE_READ_PENDING                = 0x00010000,
-  UV_HANDLE_SYNC_BYPASS_IOCP            = 0x00020000,
-  UV_HANDLE_ZERO_READ                   = 0x00040000,
-  UV_HANDLE_EMULATE_IOCP                = 0x00080000,
-  UV_HANDLE_BLOCKING_WRITES             = 0x00100000,
-  UV_HANDLE_CANCELLATION_PENDING        = 0x00200000,
-
-  /* Used by uv_tcp_t and uv_udp_t handles */
-  UV_HANDLE_IPV6                        = 0x00400000,
-
-  /* Only used by uv_tcp_t handles. */
-  UV_HANDLE_TCP_NODELAY                 = 0x01000000,
-  UV_HANDLE_TCP_KEEPALIVE               = 0x02000000,
-  UV_HANDLE_TCP_SINGLE_ACCEPT           = 0x04000000,
-  UV_HANDLE_TCP_ACCEPT_STATE_CHANGING   = 0x08000000,
-  UV_HANDLE_TCP_SOCKET_CLOSED           = 0x10000000,
-  UV_HANDLE_SHARED_TCP_SOCKET           = 0x20000000,
-
-  /* Only used by uv_udp_t handles. */
-  UV_HANDLE_UDP_PROCESSING              = 0x01000000,
-  UV_HANDLE_UDP_CONNECTED               = 0x02000000,
-
-  /* Only used by uv_pipe_t handles. */
-  UV_HANDLE_NON_OVERLAPPED_PIPE         = 0x01000000,
-  UV_HANDLE_PIPESERVER                  = 0x02000000,
-
-  /* Only used by uv_tty_t handles. */
-  UV_HANDLE_TTY_READABLE                = 0x01000000,
-  UV_HANDLE_TTY_RAW                     = 0x02000000,
-  UV_HANDLE_TTY_SAVED_POSITION          = 0x04000000,
-  UV_HANDLE_TTY_SAVED_ATTRIBUTES        = 0x08000000,
-
-  /* Only used by uv_signal_t handles. */
-  UV_SIGNAL_ONE_SHOT_DISPATCHED         = 0x01000000,
-  UV_SIGNAL_ONE_SHOT                    = 0x02000000,
-
-  /* Only used by uv_poll_t handles. */
-  UV_HANDLE_POLL_SLOW                   = 0x01000000
-};
-
-int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap);
-
-void uv__loop_close(uv_loop_t* loop);
-
-int uv__tcp_bind(uv_tcp_t* tcp,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 unsigned int flags);
-
-int uv__tcp_connect(uv_connect_t* req,
-                   uv_tcp_t* handle,
-                   const struct sockaddr* addr,
-                   unsigned int addrlen,
-                   uv_connect_cb cb);
-
-int uv__udp_bind(uv_udp_t* handle,
-                 const struct sockaddr* addr,
-                 unsigned int  addrlen,
-                 unsigned int flags);
-
-int uv__udp_connect(uv_udp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen);
-
-int uv__udp_disconnect(uv_udp_t* handle);
-
-int uv__udp_is_connected(uv_udp_t* handle);
-
-int uv__udp_send(uv_udp_send_t* req,
-                 uv_udp_t* handle,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 uv_udp_send_cb send_cb);
-
-int uv__udp_try_send(uv_udp_t* handle,
-                     const uv_buf_t bufs[],
-                     unsigned int nbufs,
-                     const struct sockaddr* addr,
-                     unsigned int addrlen);
-
-int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloccb,
-                       uv_udp_recv_cb recv_cb);
-
-int uv__udp_recv_stop(uv_udp_t* handle);
-
-void uv__fs_poll_close(uv_fs_poll_t* handle);
-
-int uv__getaddrinfo_translate_error(int sys_err);    /* EAI_* error. */
-
-enum uv__work_kind {
-  UV__WORK_CPU,
-  UV__WORK_FAST_IO,
-  UV__WORK_SLOW_IO
-};
-
-void uv__work_submit(uv_loop_t* loop,
-                     struct uv__work *w,
-                     enum uv__work_kind kind,
-                     void (*work)(struct uv__work *w),
-                     void (*done)(struct uv__work *w, int status));
-
-void uv__work_done(uv_async_t* handle);
-
-size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs);
-
-int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value);
-
-void uv__fs_scandir_cleanup(uv_fs_t* req);
-void uv__fs_readdir_cleanup(uv_fs_t* req);
-uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent);
-
-int uv__next_timeout(const uv_loop_t* loop);
-void uv__run_timers(uv_loop_t* loop);
-void uv__timer_close(uv_timer_t* handle);
-
-#define uv__has_active_reqs(loop)                                             \
-  ((loop)->active_reqs.count > 0)
-
-#define uv__req_register(loop, req)                                           \
-  do {                                                                        \
-    (loop)->active_reqs.count++;                                              \
-  }                                                                           \
-  while (0)
-
-#define uv__req_unregister(loop, req)                                         \
-  do {                                                                        \
-    assert(uv__has_active_reqs(loop));                                        \
-    (loop)->active_reqs.count--;                                              \
-  }                                                                           \
-  while (0)
-
-#define uv__has_active_handles(loop)                                          \
-  ((loop)->active_handles > 0)
-
-#define uv__active_handle_add(h)                                              \
-  do {                                                                        \
-    (h)->loop->active_handles++;                                              \
-  }                                                                           \
-  while (0)
-
-#define uv__active_handle_rm(h)                                               \
-  do {                                                                        \
-    (h)->loop->active_handles--;                                              \
-  }                                                                           \
-  while (0)
-
-#define uv__is_active(h)                                                      \
-  (((h)->flags & UV_HANDLE_ACTIVE) != 0)
-
-#define uv__is_closing(h)                                                     \
-  (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)
-
-#define uv__handle_start(h)                                                   \
-  do {                                                                        \
-    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break;                          \
-    (h)->flags |= UV_HANDLE_ACTIVE;                                           \
-    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_add(h);          \
-  }                                                                           \
-  while (0)
-
-#define uv__handle_stop(h)                                                    \
-  do {                                                                        \
-    if (((h)->flags & UV_HANDLE_ACTIVE) == 0) break;                          \
-    (h)->flags &= ~UV_HANDLE_ACTIVE;                                          \
-    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_rm(h);           \
-  }                                                                           \
-  while (0)
-
-#define uv__handle_ref(h)                                                     \
-  do {                                                                        \
-    if (((h)->flags & UV_HANDLE_REF) != 0) break;                             \
-    (h)->flags |= UV_HANDLE_REF;                                              \
-    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
-    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_add(h);       \
-  }                                                                           \
-  while (0)
-
-#define uv__handle_unref(h)                                                   \
-  do {                                                                        \
-    if (((h)->flags & UV_HANDLE_REF) == 0) break;                             \
-    (h)->flags &= ~UV_HANDLE_REF;                                             \
-    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
-    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_rm(h);        \
-  }                                                                           \
-  while (0)
-
-#define uv__has_ref(h)                                                        \
-  (((h)->flags & UV_HANDLE_REF) != 0)
-
-#if defined(_WIN32)
-# define uv__handle_platform_init(h) ((h)->u.fd = -1)
-#else
-# define uv__handle_platform_init(h) ((h)->next_closing = NULL)
-#endif
-
-#define uv__handle_init(loop_, h, type_)                                      \
-  do {                                                                        \
-    (h)->loop = (loop_);                                                      \
-    (h)->type = (type_);                                                      \
-    (h)->flags = UV_HANDLE_REF;  /* Ref the loop when active. */              \
-    QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue);            \
-    uv__handle_platform_init(h);                                              \
-  }                                                                           \
-  while (0)
-
-/* Note: uses an open-coded version of SET_REQ_SUCCESS() because of
- * a circular dependency between src/uv-common.h and src/win/internal.h.
- */
-#if defined(_WIN32)
-# define UV_REQ_INIT(req, typ)                                                \
-  do {                                                                        \
-    (req)->type = (typ);                                                      \
-    (req)->u.io.overlapped.Internal = 0;  /* SET_REQ_SUCCESS() */             \
-  }                                                                           \
-  while (0)
-#else
-# define UV_REQ_INIT(req, typ)                                                \
-  do {                                                                        \
-    (req)->type = (typ);                                                      \
-  }                                                                           \
-  while (0)
-#endif
-
-#define uv__req_init(loop, req, typ)                                          \
-  do {                                                                        \
-    UV_REQ_INIT(req, typ);                                                    \
-    uv__req_register(loop, req);                                              \
-  }                                                                           \
-  while (0)
-
-/* Allocator prototypes */
-void *uv__calloc(size_t count, size_t size);
-char *uv__strdup(const char* s);
-char *uv__strndup(const char* s, size_t n);
-void* uv__malloc(size_t size);
-void uv__free(void* ptr);
-void* uv__realloc(void* ptr, size_t size);
-
-#endif /* UV_COMMON_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/uv-data-getter-setters.cpp b/wpiutil/src/main/native/libuv/src/uv-data-getter-setters.cpp
deleted file mode 100644
index c302566..0000000
--- a/wpiutil/src/main/native/libuv/src/uv-data-getter-setters.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "uv.h"
-
-const char* uv_handle_type_name(uv_handle_type type) {
-  switch (type) {
-#define XX(uc,lc) case UV_##uc: return #lc;
-  UV_HANDLE_TYPE_MAP(XX)
-#undef XX
-  case UV_FILE: return "file";
-  case UV_HANDLE_TYPE_MAX:
-  case UV_UNKNOWN_HANDLE: return NULL;
-  }
-  return NULL;
-}
-
-uv_handle_type uv_handle_get_type(const uv_handle_t* handle) {
-  return handle->type;
-}
-
-void* uv_handle_get_data(const uv_handle_t* handle) {
-  return handle->data;
-}
-
-uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle) {
-  return handle->loop;
-}
-
-void uv_handle_set_data(uv_handle_t* handle, void* data) {
-  handle->data = data;
-}
-
-const char* uv_req_type_name(uv_req_type type) {
-  switch (type) {
-#define XX(uc,lc) case UV_##uc: return #lc;
-  UV_REQ_TYPE_MAP(XX)
-#undef XX
-  case UV_REQ_TYPE_MAX:
-  case UV_UNKNOWN_REQ:
-  default: /* UV_REQ_TYPE_PRIVATE */
-    break;
-  }
-  return NULL;
-}
-
-uv_req_type uv_req_get_type(const uv_req_t* req) {
-  return req->type;
-}
-
-void* uv_req_get_data(const uv_req_t* req) {
-  return req->data;
-}
-
-void uv_req_set_data(uv_req_t* req, void* data) {
-  req->data = data;
-}
-
-size_t uv_stream_get_write_queue_size(const uv_stream_t* stream) {
-  return stream->write_queue_size;
-}
-
-size_t uv_udp_get_send_queue_size(const uv_udp_t* handle) {
-  return handle->send_queue_size;
-}
-
-size_t uv_udp_get_send_queue_count(const uv_udp_t* handle) {
-  return handle->send_queue_count;
-}
-
-uv_pid_t uv_process_get_pid(const uv_process_t* proc) {
-  return proc->pid;
-}
-
-uv_fs_type uv_fs_get_type(const uv_fs_t* req) {
-  return req->fs_type;
-}
-
-ssize_t uv_fs_get_result(const uv_fs_t* req) {
-  return req->result;
-}
-
-void* uv_fs_get_ptr(const uv_fs_t* req) {
-  return req->ptr;
-}
-
-const char* uv_fs_get_path(const uv_fs_t* req) {
-  return req->path;
-}
-
-uv_stat_t* uv_fs_get_statbuf(uv_fs_t* req) {
-  return &req->statbuf;
-}
-
-void* uv_loop_get_data(const uv_loop_t* loop) {
-  return loop->data;
-}
-
-void uv_loop_set_data(uv_loop_t* loop, void* data) {
-  loop->data = data;
-}
diff --git a/wpiutil/src/main/native/libuv/src/version.cpp b/wpiutil/src/main/native/libuv/src/version.cpp
deleted file mode 100644
index 686dedd..0000000
--- a/wpiutil/src/main/native/libuv/src/version.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-
-#define UV_STRINGIFY(v) UV_STRINGIFY_HELPER(v)
-#define UV_STRINGIFY_HELPER(v) #v
-
-#define UV_VERSION_STRING_BASE  UV_STRINGIFY(UV_VERSION_MAJOR) "." \
-                                UV_STRINGIFY(UV_VERSION_MINOR) "." \
-                                UV_STRINGIFY(UV_VERSION_PATCH)
-
-#if UV_VERSION_IS_RELEASE
-# define UV_VERSION_STRING  UV_VERSION_STRING_BASE
-#else
-# define UV_VERSION_STRING  UV_VERSION_STRING_BASE "-" UV_VERSION_SUFFIX
-#endif
-
-
-unsigned int uv_version(void) {
-  return UV_VERSION_HEX;
-}
-
-
-const char* uv_version_string(void) {
-  return UV_VERSION_STRING;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/async.cpp b/wpiutil/src/main/native/libuv/src/win/async.cpp
deleted file mode 100644
index d787f66..0000000
--- a/wpiutil/src/main/native/libuv/src/win/async.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "atomicops-inl.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) {
-  if (handle->flags & UV_HANDLE_CLOSING &&
-      !handle->async_sent) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-    uv__handle_close(handle);
-  }
-}
-
-
-int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) {
-  uv_req_t* req;
-
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_ASYNC);
-  handle->async_sent = 0;
-  handle->async_cb = async_cb;
-
-  req = &handle->async_req;
-  UV_REQ_INIT(req, UV_WAKEUP);
-  req->data = handle;
-
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-void uv_async_close(uv_loop_t* loop, uv_async_t* handle) {
-  if (!((uv_async_t*)handle)->async_sent) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-
-  uv__handle_closing(handle);
-}
-
-
-int uv_async_send(uv_async_t* handle) {
-  uv_loop_t* loop = handle->loop;
-
-  if (handle->type != UV_ASYNC) {
-    /* Can't set errno because that's not thread-safe. */
-    return -1;
-  }
-
-  /* The user should make sure never to call uv_async_send to a closing or
-   * closed handle. */
-  assert(!(handle->flags & UV_HANDLE_CLOSING));
-
-  if (!uv__atomic_exchange_set(&handle->async_sent)) {
-    POST_COMPLETION_FOR_REQ(loop, &handle->async_req);
-  }
-
-  return 0;
-}
-
-
-void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
-    uv_req_t* req) {
-  assert(handle->type == UV_ASYNC);
-  assert(req->type == UV_WAKEUP);
-
-  handle->async_sent = 0;
-
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  } else if (handle->async_cb != NULL) {
-    handle->async_cb(handle);
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/atomicops-inl.h b/wpiutil/src/main/native/libuv/src/win/atomicops-inl.h
deleted file mode 100644
index 52713cf..0000000
--- a/wpiutil/src/main/native/libuv/src/win/atomicops-inl.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_ATOMICOPS_INL_H_
-#define UV_WIN_ATOMICOPS_INL_H_
-
-#include "uv.h"
-#include "internal.h"
-
-
-/* Atomic set operation on char */
-#ifdef _MSC_VER /* MSVC */
-
-/* _InterlockedOr8 is supported by MSVC on x32 and x64. It is slightly less
- * efficient than InterlockedExchange, but InterlockedExchange8 does not exist,
- * and interlocked operations on larger targets might require the target to be
- * aligned. */
-#pragma intrinsic(_InterlockedOr8)
-
-static char INLINE uv__atomic_exchange_set(char volatile* target) {
-  return _InterlockedOr8(target, 1);
-}
-
-#else /* GCC */
-
-/* Mingw-32 version, hopefully this works for 64-bit gcc as well. */
-static inline char uv__atomic_exchange_set(char volatile* target) {
-  const char one = 1;
-  char old_value;
-  __asm__ __volatile__ ("lock xchgb %0, %1\n\t"
-                        : "=r"(old_value), "=m"(*target)
-                        : "0"(one), "m"(*target)
-                        : "memory");
-  return old_value;
-}
-
-#endif
-
-#endif /* UV_WIN_ATOMICOPS_INL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/core.cpp b/wpiutil/src/main/native/libuv/src/win/core.cpp
deleted file mode 100644
index 1e162dd..0000000
--- a/wpiutil/src/main/native/libuv/src/win/core.cpp
+++ /dev/null
@@ -1,654 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <errno.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#if defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR)
-#include <crtdbg.h>
-#endif
-
-#include "uv.h"
-#include "internal.h"
-#include "queue.h"
-#include "handle-inl.h"
-#include "heap-inl.h"
-#include "req-inl.h"
-
-/* uv_once initialization guards */
-static uv_once_t uv_init_guard_ = UV_ONCE_INIT;
-
-
-#if defined(_DEBUG) && (defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR))
-/* Our crt debug report handler allows us to temporarily disable asserts
- * just for the current thread.
- */
-
-UV_THREAD_LOCAL int uv__crt_assert_enabled = TRUE;
-
-static int uv__crt_dbg_report_handler(int report_type, char *message, int *ret_val) {
-  if (uv__crt_assert_enabled || report_type != _CRT_ASSERT)
-    return FALSE;
-
-  if (ret_val) {
-    /* Set ret_val to 0 to continue with normal execution.
-     * Set ret_val to 1 to trigger a breakpoint.
-    */
-
-    if(IsDebuggerPresent())
-      *ret_val = 1;
-    else
-      *ret_val = 0;
-  }
-
-  /* Don't call _CrtDbgReport. */
-  return TRUE;
-}
-#else
-UV_THREAD_LOCAL int uv__crt_assert_enabled = FALSE;
-#endif
-
-
-#if !defined(__MINGW32__) || __MSVCRT_VERSION__ >= 0x800
-static void uv__crt_invalid_parameter_handler(const wchar_t* expression,
-    const wchar_t* function, const wchar_t * file, unsigned int line,
-    uintptr_t reserved) {
-  /* No-op. */
-}
-#endif
-
-static uv_loop_t** uv__loops;
-static int uv__loops_size;
-static int uv__loops_capacity;
-#define UV__LOOPS_CHUNK_SIZE 8
-static uv_mutex_t uv__loops_lock;
-
-static void uv__loops_init(void) {
-  uv_mutex_init(&uv__loops_lock);
-}
-
-static int uv__loops_add(uv_loop_t* loop) {
-  uv_loop_t** new_loops;
-  int new_capacity, i;
-
-  uv_mutex_lock(&uv__loops_lock);
-
-  if (uv__loops_size == uv__loops_capacity) {
-    new_capacity = uv__loops_capacity + UV__LOOPS_CHUNK_SIZE;
-    new_loops = (uv_loop_t**)
-        uv__realloc(uv__loops, sizeof(uv_loop_t*) * new_capacity);
-    if (!new_loops)
-      goto failed_loops_realloc;
-    uv__loops = new_loops;
-    for (i = uv__loops_capacity; i < new_capacity; ++i)
-      uv__loops[i] = NULL;
-    uv__loops_capacity = new_capacity;
-  }
-  uv__loops[uv__loops_size] = loop;
-  ++uv__loops_size;
-
-  uv_mutex_unlock(&uv__loops_lock);
-  return 0;
-
-failed_loops_realloc:
-  uv_mutex_unlock(&uv__loops_lock);
-  return ERROR_OUTOFMEMORY;
-}
-
-static void uv__loops_remove(uv_loop_t* loop) {
-  int loop_index;
-  int smaller_capacity;
-  uv_loop_t** new_loops;
-
-  uv_mutex_lock(&uv__loops_lock);
-
-  for (loop_index = 0; loop_index < uv__loops_size; ++loop_index) {
-    if (uv__loops[loop_index] == loop)
-      break;
-  }
-  /* If loop was not found, ignore */
-  if (loop_index == uv__loops_size)
-    goto loop_removed;
-
-  uv__loops[loop_index] = uv__loops[uv__loops_size - 1];
-  uv__loops[uv__loops_size - 1] = NULL;
-  --uv__loops_size;
-
-  if (uv__loops_size == 0) {
-    uv__loops_capacity = 0;
-    uv__free(uv__loops);
-    uv__loops = NULL;
-    goto loop_removed;
-  }
-
-  /* If we didn't grow to big skip downsizing */
-  if (uv__loops_capacity < 4 * UV__LOOPS_CHUNK_SIZE)
-    goto loop_removed;
-
-  /* Downsize only if more than half of buffer is free */
-  smaller_capacity = uv__loops_capacity / 2;
-  if (uv__loops_size >= smaller_capacity)
-    goto loop_removed;
-  new_loops = (uv_loop_t**)
-      uv__realloc(uv__loops, sizeof(uv_loop_t*) * smaller_capacity);
-  if (!new_loops)
-    goto loop_removed;
-  uv__loops = new_loops;
-  uv__loops_capacity = smaller_capacity;
-
-loop_removed:
-  uv_mutex_unlock(&uv__loops_lock);
-}
-
-void uv__wake_all_loops(void) {
-  int i;
-  uv_loop_t* loop;
-
-  uv_mutex_lock(&uv__loops_lock);
-  for (i = 0; i < uv__loops_size; ++i) {
-    loop = uv__loops[i];
-    assert(loop);
-    if (loop->iocp != INVALID_HANDLE_VALUE)
-      PostQueuedCompletionStatus(loop->iocp, 0, 0, NULL);
-  }
-  uv_mutex_unlock(&uv__loops_lock);
-}
-
-static void uv_init(void) {
-  /* Tell Windows that we will handle critical errors. */
-  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
-               SEM_NOOPENFILEERRORBOX);
-
-  /* Tell the CRT to not exit the application when an invalid parameter is
-   * passed. The main issue is that invalid FDs will trigger this behavior.
-   */
-#if !defined(__MINGW32__) || __MSVCRT_VERSION__ >= 0x800
-  _set_invalid_parameter_handler(uv__crt_invalid_parameter_handler);
-#endif
-
-  /* We also need to setup our debug report handler because some CRT
-   * functions (eg _get_osfhandle) raise an assert when called with invalid
-   * FDs even though they return the proper error code in the release build.
-   */
-#if defined(_DEBUG) && (defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR))
-  _CrtSetReportHook(uv__crt_dbg_report_handler);
-#endif
-
-  /* Initialize tracking of all uv loops */
-  uv__loops_init();
-
-  /* Fetch winapi function pointers. This must be done first because other
-   * initialization code might need these function pointers to be loaded.
-   */
-  uv_winapi_init();
-
-  /* Initialize winsock */
-  uv_winsock_init();
-
-  /* Initialize FS */
-  uv_fs_init();
-
-  /* Initialize signal stuff */
-  uv_signals_init();
-
-  /* Initialize console */
-  uv_console_init();
-
-  /* Initialize utilities */
-  uv__util_init();
-
-  /* Initialize system wakeup detection */
-  uv__init_detect_system_wakeup();
-}
-
-
-int uv_loop_init(uv_loop_t* loop) {
-  struct heap* timer_heap;
-  int err;
-
-  /* Initialize libuv itself first */
-  uv__once_init();
-
-  /* Create an I/O completion port */
-  loop->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
-  if (loop->iocp == NULL)
-    return uv_translate_sys_error(GetLastError());
-
-  /* To prevent uninitialized memory access, loop->time must be initialized
-   * to zero before calling uv_update_time for the first time.
-   */
-  loop->time = 0;
-  uv_update_time(loop);
-
-  QUEUE_INIT(&loop->wq);
-  QUEUE_INIT(&loop->handle_queue);
-  loop->active_reqs.count = 0;
-  loop->active_handles = 0;
-
-  loop->pending_reqs_tail = NULL;
-
-  loop->endgame_handles = NULL;
-
-  loop->timer_heap = timer_heap = (heap*)uv__malloc(sizeof(*timer_heap));
-  if (timer_heap == NULL) {
-    err = UV_ENOMEM;
-    goto fail_timers_alloc;
-  }
-
-  heap_init(timer_heap);
-
-  loop->check_handles = NULL;
-  loop->prepare_handles = NULL;
-  loop->idle_handles = NULL;
-
-  loop->next_prepare_handle = NULL;
-  loop->next_check_handle = NULL;
-  loop->next_idle_handle = NULL;
-
-  memset(&loop->poll_peer_sockets, 0, sizeof loop->poll_peer_sockets);
-
-  loop->active_tcp_streams = 0;
-  loop->active_udp_streams = 0;
-
-  loop->timer_counter = 0;
-  loop->stop_flag = 0;
-
-  err = uv_mutex_init(&loop->wq_mutex);
-  if (err)
-    goto fail_mutex_init;
-
-  err = uv_async_init(loop, &loop->wq_async, uv__work_done);
-  if (err)
-    goto fail_async_init;
-
-  uv__handle_unref(&loop->wq_async);
-  loop->wq_async.flags |= UV_HANDLE_INTERNAL;
-
-  err = uv__loops_add(loop);
-  if (err)
-    goto fail_async_init;
-
-  return 0;
-
-fail_async_init:
-  uv_mutex_destroy(&loop->wq_mutex);
-
-fail_mutex_init:
-  uv__free(timer_heap);
-  loop->timer_heap = NULL;
-
-fail_timers_alloc:
-  CloseHandle(loop->iocp);
-  loop->iocp = INVALID_HANDLE_VALUE;
-
-  return err;
-}
-
-
-void uv_update_time(uv_loop_t* loop) {
-  uint64_t new_time = uv__hrtime(1000);
-  assert(new_time >= loop->time);
-  loop->time = new_time;
-}
-
-
-void uv__once_init(void) {
-  uv_once(&uv_init_guard_, uv_init);
-}
-
-
-void uv__loop_close(uv_loop_t* loop) {
-  size_t i;
-
-  uv__loops_remove(loop);
-
-  /* close the async handle without needing an extra loop iteration */
-  assert(!loop->wq_async.async_sent);
-  loop->wq_async.close_cb = NULL;
-  uv__handle_closing(&loop->wq_async);
-  uv__handle_close(&loop->wq_async);
-
-  for (i = 0; i < ARRAY_SIZE(loop->poll_peer_sockets); i++) {
-    SOCKET sock = loop->poll_peer_sockets[i];
-    if (sock != 0 && sock != INVALID_SOCKET)
-      closesocket(sock);
-  }
-
-  uv_mutex_lock(&loop->wq_mutex);
-  assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
-  assert(!uv__has_active_reqs(loop));
-  uv_mutex_unlock(&loop->wq_mutex);
-  uv_mutex_destroy(&loop->wq_mutex);
-
-  uv__free(loop->timer_heap);
-  loop->timer_heap = NULL;
-
-  CloseHandle(loop->iocp);
-}
-
-
-int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap) {
-  return UV_ENOSYS;
-}
-
-
-int uv_backend_fd(const uv_loop_t* loop) {
-  return -1;
-}
-
-
-int uv_loop_fork(uv_loop_t* loop) {
-  return UV_ENOSYS;
-}
-
-
-int uv_backend_timeout(const uv_loop_t* loop) {
-  if (loop->stop_flag != 0)
-    return 0;
-
-  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
-    return 0;
-
-  if (loop->pending_reqs_tail)
-    return 0;
-
-  if (loop->endgame_handles)
-    return 0;
-
-  if (loop->idle_handles)
-    return 0;
-
-  return uv__next_timeout(loop);
-}
-
-
-static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) {
-  DWORD bytes;
-  ULONG_PTR key;
-  OVERLAPPED* overlapped;
-  uv_req_t* req;
-  int repeat;
-  uint64_t timeout_time;
-
-  timeout_time = loop->time + timeout;
-
-  for (repeat = 0; ; repeat++) {
-    GetQueuedCompletionStatus(loop->iocp,
-                              &bytes,
-                              &key,
-                              &overlapped,
-                              timeout);
-
-    if (overlapped) {
-      /* Package was dequeued */
-      req = uv_overlapped_to_req(overlapped);
-      uv_insert_pending_req(loop, req);
-
-      /* Some time might have passed waiting for I/O,
-       * so update the loop time here.
-       */
-      uv_update_time(loop);
-    } else if (GetLastError() != WAIT_TIMEOUT) {
-      /* Serious error */
-      uv_fatal_error(GetLastError(), "GetQueuedCompletionStatus");
-    } else if (timeout > 0) {
-      /* GetQueuedCompletionStatus can occasionally return a little early.
-       * Make sure that the desired timeout target time is reached.
-       */
-      uv_update_time(loop);
-      if (timeout_time > loop->time) {
-        timeout = (DWORD)(timeout_time - loop->time);
-        /* The first call to GetQueuedCompletionStatus should return very
-         * close to the target time and the second should reach it, but
-         * this is not stated in the documentation. To make sure a busy
-         * loop cannot happen, the timeout is increased exponentially
-         * starting on the third round.
-         */
-        timeout += repeat ? (1 << (repeat - 1)) : 0;
-        continue;
-      }
-    }
-    break;
-  }
-}
-
-
-static void uv__poll(uv_loop_t* loop, DWORD timeout) {
-  BOOL success;
-  uv_req_t* req;
-  OVERLAPPED_ENTRY overlappeds[128];
-  ULONG count;
-  ULONG i;
-  int repeat;
-  uint64_t timeout_time;
-
-  timeout_time = loop->time + timeout;
-
-  for (repeat = 0; ; repeat++) {
-    success = GetQueuedCompletionStatusEx(loop->iocp,
-                                          overlappeds,
-                                          ARRAY_SIZE(overlappeds),
-                                          &count,
-                                          timeout,
-                                          FALSE);
-
-    if (success) {
-      for (i = 0; i < count; i++) {
-        /* Package was dequeued, but see if it is not a empty package
-         * meant only to wake us up.
-         */
-        if (overlappeds[i].lpOverlapped) {
-          req = uv_overlapped_to_req(overlappeds[i].lpOverlapped);
-          uv_insert_pending_req(loop, req);
-        }
-      }
-
-      /* Some time might have passed waiting for I/O,
-       * so update the loop time here.
-       */
-      uv_update_time(loop);
-    } else if (GetLastError() != WAIT_TIMEOUT) {
-      /* Serious error */
-      uv_fatal_error(GetLastError(), "GetQueuedCompletionStatusEx");
-    } else if (timeout > 0) {
-      /* GetQueuedCompletionStatus can occasionally return a little early.
-       * Make sure that the desired timeout target time is reached.
-       */
-      uv_update_time(loop);
-      if (timeout_time > loop->time) {
-        timeout = (DWORD)(timeout_time - loop->time);
-        /* The first call to GetQueuedCompletionStatus should return very
-         * close to the target time and the second should reach it, but
-         * this is not stated in the documentation. To make sure a busy
-         * loop cannot happen, the timeout is increased exponentially
-         * starting on the third round.
-         */
-        timeout += repeat ? (1 << (repeat - 1)) : 0;
-        continue;
-      }
-    }
-    break;
-  }
-}
-
-
-static int uv__loop_alive(const uv_loop_t* loop) {
-  return uv__has_active_handles(loop) ||
-         uv__has_active_reqs(loop) ||
-         loop->endgame_handles != NULL;
-}
-
-
-int uv_loop_alive(const uv_loop_t* loop) {
-    return uv__loop_alive(loop);
-}
-
-
-int uv_run(uv_loop_t *loop, uv_run_mode mode) {
-  DWORD timeout;
-  int r;
-  int ran_pending;
-
-  r = uv__loop_alive(loop);
-  if (!r)
-    uv_update_time(loop);
-
-  while (r != 0 && loop->stop_flag == 0) {
-    uv_update_time(loop);
-    uv__run_timers(loop);
-
-    ran_pending = uv_process_reqs(loop);
-    uv_idle_invoke(loop);
-    uv_prepare_invoke(loop);
-
-    timeout = 0;
-    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
-      timeout = uv_backend_timeout(loop);
-
-    if (pGetQueuedCompletionStatusEx)
-      uv__poll(loop, timeout);
-    else
-      uv__poll_wine(loop, timeout);
-
-
-    uv_check_invoke(loop);
-    uv_process_endgames(loop);
-
-    if (mode == UV_RUN_ONCE) {
-      /* UV_RUN_ONCE implies forward progress: at least one callback must have
-       * been invoked when it returns. uv__io_poll() can return without doing
-       * I/O (meaning: no callbacks) when its timeout expires - which means we
-       * have pending timers that satisfy the forward progress constraint.
-       *
-       * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
-       * the check.
-       */
-      uv__run_timers(loop);
-    }
-
-    r = uv__loop_alive(loop);
-    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
-      break;
-  }
-
-  /* The if statement lets the compiler compile it to a conditional store.
-   * Avoids dirtying a cache line.
-   */
-  if (loop->stop_flag != 0)
-    loop->stop_flag = 0;
-
-  return r;
-}
-
-
-int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) {
-  uv_os_fd_t fd_out;
-
-  switch (handle->type) {
-  case UV_TCP:
-    fd_out = (uv_os_fd_t)((uv_tcp_t*) handle)->socket;
-    break;
-
-  case UV_NAMED_PIPE:
-    fd_out = ((uv_pipe_t*) handle)->handle;
-    break;
-
-  case UV_TTY:
-    fd_out = ((uv_tty_t*) handle)->handle;
-    break;
-
-  case UV_UDP:
-    fd_out = (uv_os_fd_t)((uv_udp_t*) handle)->socket;
-    break;
-
-  case UV_POLL:
-    fd_out = (uv_os_fd_t)((uv_poll_t*) handle)->socket;
-    break;
-
-  default:
-    return UV_EINVAL;
-  }
-
-  if (uv_is_closing(handle) || fd_out == INVALID_HANDLE_VALUE)
-    return UV_EBADF;
-
-  *fd = fd_out;
-  return 0;
-}
-
-
-int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value) {
-  int r;
-  int len;
-  SOCKET socket;
-
-  if (handle == NULL || value == NULL)
-    return UV_EINVAL;
-
-  if (handle->type == UV_TCP)
-    socket = ((uv_tcp_t*) handle)->socket;
-  else if (handle->type == UV_UDP)
-    socket = ((uv_udp_t*) handle)->socket;
-  else
-    return UV_ENOTSUP;
-
-  len = sizeof(*value);
-
-  if (*value == 0)
-    r = getsockopt(socket, SOL_SOCKET, optname, (char*) value, &len);
-  else
-    r = setsockopt(socket, SOL_SOCKET, optname, (const char*) value, len);
-
-  if (r == SOCKET_ERROR)
-    return uv_translate_sys_error(WSAGetLastError());
-
-  return 0;
-}
-
-int uv_cpumask_size(void) {
-  return (int)(sizeof(DWORD_PTR) * 8);
-}
-
-int uv__getsockpeername(const uv_handle_t* handle,
-                        uv__peersockfunc func,
-                        struct sockaddr* name,
-                        int* namelen,
-                        int delayed_error) {
-
-  int result;
-  uv_os_fd_t fd;
-
-  result = uv_fileno(handle, &fd);
-  if (result != 0)
-    return result;
-
-  if (delayed_error)
-    return uv_translate_sys_error(delayed_error);
-
-  result = func((SOCKET) fd, name, namelen);
-  if (result != 0)
-    return uv_translate_sys_error(WSAGetLastError());
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/detect-wakeup.cpp b/wpiutil/src/main/native/libuv/src/win/detect-wakeup.cpp
deleted file mode 100644
index 72dfb7a..0000000
--- a/wpiutil/src/main/native/libuv/src/win/detect-wakeup.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "uv.h"
-#include "internal.h"
-#include "winapi.h"
-
-static void uv__register_system_resume_callback(void);
-
-void uv__init_detect_system_wakeup(void) {
-  /* Try registering system power event callback. This is the cleanest
-   * method, but it will only work on Win8 and above.
-   */
-  uv__register_system_resume_callback();
-}
-
-static ULONG CALLBACK uv__system_resume_callback(PVOID Context,
-                                                 ULONG Type,
-                                                 PVOID Setting) {
-  if (Type == PBT_APMRESUMESUSPEND || Type == PBT_APMRESUMEAUTOMATIC)
-    uv__wake_all_loops();
-
-  return 0;
-}
-
-static void uv__register_system_resume_callback(void) {
-  _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS recipient;
-  _HPOWERNOTIFY registration_handle;
-
-  if (pPowerRegisterSuspendResumeNotification == NULL)
-    return;
-
-  recipient.Callback = uv__system_resume_callback;
-  recipient.Context = NULL;
-  (*pPowerRegisterSuspendResumeNotification)(DEVICE_NOTIFY_CALLBACK,
-                                             &recipient,
-                                             &registration_handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/dl.cpp b/wpiutil/src/main/native/libuv/src/win/dl.cpp
deleted file mode 100644
index 676be4d..0000000
--- a/wpiutil/src/main/native/libuv/src/win/dl.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "uv.h"
-#include "internal.h"
-
-static int uv__dlerror(uv_lib_t* lib, const char* filename, DWORD errorno);
-
-
-int uv_dlopen(const char* filename, uv_lib_t* lib) {
-  WCHAR filename_w[32768];
-
-  lib->handle = NULL;
-  lib->errmsg = NULL;
-
-  if (!MultiByteToWideChar(CP_UTF8,
-                           0,
-                           filename,
-                           -1,
-                           filename_w,
-                           ARRAY_SIZE(filename_w))) {
-    return uv__dlerror(lib, filename, GetLastError());
-  }
-
-  lib->handle = LoadLibraryExW(filename_w, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
-  if (lib->handle == NULL) {
-    return uv__dlerror(lib, filename, GetLastError());
-  }
-
-  return 0;
-}
-
-
-void uv_dlclose(uv_lib_t* lib) {
-  if (lib->errmsg) {
-    LocalFree((void*)lib->errmsg);
-    lib->errmsg = NULL;
-  }
-
-  if (lib->handle) {
-    /* Ignore errors. No good way to signal them without leaking memory. */
-    FreeLibrary(lib->handle);
-    lib->handle = NULL;
-  }
-}
-
-
-int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr) {
-  /* Cast though integer to suppress pedantic warning about forbidden cast. */
-  *ptr = (void*)(uintptr_t) GetProcAddress(lib->handle, name);
-  return uv__dlerror(lib, "", *ptr ? 0 : GetLastError());
-}
-
-
-const char* uv_dlerror(const uv_lib_t* lib) {
-  return lib->errmsg ? lib->errmsg : "no error";
-}
-
-
-static void uv__format_fallback_error(uv_lib_t* lib, int errorno){
-  static const CHAR fallback_error[] = "error: %1!d!";
-  DWORD_PTR args[1];
-  args[0] = (DWORD_PTR) errorno;
-
-  FormatMessageA(FORMAT_MESSAGE_FROM_STRING |
-                 FORMAT_MESSAGE_ARGUMENT_ARRAY |
-                 FORMAT_MESSAGE_ALLOCATE_BUFFER,
-                 fallback_error, 0, 0,
-                 (LPSTR) &lib->errmsg,
-                 0, (va_list*) args);
-}
-
-
-
-static int uv__dlerror(uv_lib_t* lib, const char* filename, DWORD errorno) {
-  DWORD_PTR arg;
-  DWORD res;
-  char* msg;
-
-  if (lib->errmsg) {
-    LocalFree(lib->errmsg);
-    lib->errmsg = NULL;
-  }
-
-  if (errorno == 0)
-    return 0;
-
-  res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                       FORMAT_MESSAGE_FROM_SYSTEM |
-                       FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
-                       MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
-                       (LPSTR) &lib->errmsg, 0, NULL);
-
-  if (!res && (GetLastError() == ERROR_MUI_FILE_NOT_FOUND ||
-               GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND)) {
-    res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                         FORMAT_MESSAGE_FROM_SYSTEM |
-                         FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
-                         0, (LPSTR) &lib->errmsg, 0, NULL);
-  }
-
-  if (res && errorno == ERROR_BAD_EXE_FORMAT && strstr(lib->errmsg, "%1")) {
-    msg = lib->errmsg;
-    lib->errmsg = NULL;
-    arg = (DWORD_PTR) filename;
-    res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                         FORMAT_MESSAGE_ARGUMENT_ARRAY |
-                         FORMAT_MESSAGE_FROM_STRING,
-                         msg,
-                         0, 0, (LPSTR) &lib->errmsg, 0, (va_list*) &arg);
-    LocalFree(msg);
-  }
-
-  if (!res)
-    uv__format_fallback_error(lib, errorno);
-
-  return -1;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/error.cpp b/wpiutil/src/main/native/libuv/src/win/error.cpp
deleted file mode 100644
index 24924ba..0000000
--- a/wpiutil/src/main/native/libuv/src/win/error.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-/*
- * Display an error message and abort the event loop.
- */
-void uv_fatal_error(const int errorno, const char* syscall) {
-  char* buf = NULL;
-  const char* errmsg;
-
-  FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
-      FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
-      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&buf, 0, NULL);
-
-  if (buf) {
-    errmsg = buf;
-  } else {
-    errmsg = "Unknown error";
-  }
-
-  /* FormatMessage messages include a newline character already, so don't add
-   * another. */
-  if (syscall) {
-    fprintf(stderr, "%s: (%d) %s", syscall, errorno, errmsg);
-  } else {
-    fprintf(stderr, "(%d) %s", errorno, errmsg);
-  }
-
-  if (buf) {
-    LocalFree(buf);
-  }
-
-  DebugBreak();
-  abort();
-}
-
-
-int uv_translate_sys_error(int sys_errno) {
-  if (sys_errno <= 0) {
-    return sys_errno;  /* If < 0 then it's already a libuv error. */
-  }
-
-  switch (sys_errno) {
-    case ERROR_NOACCESS:                    return UV_EACCES;
-    case WSAEACCES:                         return UV_EACCES;
-    case ERROR_ELEVATION_REQUIRED:          return UV_EACCES;
-    case ERROR_ADDRESS_ALREADY_ASSOCIATED:  return UV_EADDRINUSE;
-    case WSAEADDRINUSE:                     return UV_EADDRINUSE;
-    case WSAEADDRNOTAVAIL:                  return UV_EADDRNOTAVAIL;
-    case WSAEAFNOSUPPORT:                   return UV_EAFNOSUPPORT;
-    case WSAEWOULDBLOCK:                    return UV_EAGAIN;
-    case WSAEALREADY:                       return UV_EALREADY;
-    case ERROR_INVALID_FLAGS:               return UV_EBADF;
-    case ERROR_INVALID_HANDLE:              return UV_EBADF;
-    case ERROR_LOCK_VIOLATION:              return UV_EBUSY;
-    case ERROR_PIPE_BUSY:                   return UV_EBUSY;
-    case ERROR_SHARING_VIOLATION:           return UV_EBUSY;
-    case ERROR_OPERATION_ABORTED:           return UV_ECANCELED;
-    case WSAEINTR:                          return UV_ECANCELED;
-    case ERROR_NO_UNICODE_TRANSLATION:      return UV_ECHARSET;
-    case ERROR_CONNECTION_ABORTED:          return UV_ECONNABORTED;
-    case WSAECONNABORTED:                   return UV_ECONNABORTED;
-    case ERROR_CONNECTION_REFUSED:          return UV_ECONNREFUSED;
-    case WSAECONNREFUSED:                   return UV_ECONNREFUSED;
-    case ERROR_NETNAME_DELETED:             return UV_ECONNRESET;
-    case WSAECONNRESET:                     return UV_ECONNRESET;
-    case ERROR_ALREADY_EXISTS:              return UV_EEXIST;
-    case ERROR_FILE_EXISTS:                 return UV_EEXIST;
-    case ERROR_BUFFER_OVERFLOW:             return UV_EFAULT;
-    case WSAEFAULT:                         return UV_EFAULT;
-    case ERROR_HOST_UNREACHABLE:            return UV_EHOSTUNREACH;
-    case WSAEHOSTUNREACH:                   return UV_EHOSTUNREACH;
-    case ERROR_INSUFFICIENT_BUFFER:         return UV_EINVAL;
-    case ERROR_INVALID_DATA:                return UV_EINVAL;
-    case ERROR_INVALID_PARAMETER:           return UV_EINVAL;
-    case ERROR_SYMLINK_NOT_SUPPORTED:       return UV_EINVAL;
-    case WSAEINVAL:                         return UV_EINVAL;
-    case WSAEPFNOSUPPORT:                   return UV_EINVAL;
-    case WSAESOCKTNOSUPPORT:                return UV_EINVAL;
-    case ERROR_BEGINNING_OF_MEDIA:          return UV_EIO;
-    case ERROR_BUS_RESET:                   return UV_EIO;
-    case ERROR_CRC:                         return UV_EIO;
-    case ERROR_DEVICE_DOOR_OPEN:            return UV_EIO;
-    case ERROR_DEVICE_REQUIRES_CLEANING:    return UV_EIO;
-    case ERROR_DISK_CORRUPT:                return UV_EIO;
-    case ERROR_EOM_OVERFLOW:                return UV_EIO;
-    case ERROR_FILEMARK_DETECTED:           return UV_EIO;
-    case ERROR_GEN_FAILURE:                 return UV_EIO;
-    case ERROR_INVALID_BLOCK_LENGTH:        return UV_EIO;
-    case ERROR_IO_DEVICE:                   return UV_EIO;
-    case ERROR_NO_DATA_DETECTED:            return UV_EIO;
-    case ERROR_NO_SIGNAL_SENT:              return UV_EIO;
-    case ERROR_OPEN_FAILED:                 return UV_EIO;
-    case ERROR_SETMARK_DETECTED:            return UV_EIO;
-    case ERROR_SIGNAL_REFUSED:              return UV_EIO;
-    case WSAEISCONN:                        return UV_EISCONN;
-    case ERROR_CANT_RESOLVE_FILENAME:       return UV_ELOOP;
-    case ERROR_TOO_MANY_OPEN_FILES:         return UV_EMFILE;
-    case WSAEMFILE:                         return UV_EMFILE;
-    case WSAEMSGSIZE:                       return UV_EMSGSIZE;
-    case ERROR_FILENAME_EXCED_RANGE:        return UV_ENAMETOOLONG;
-    case ERROR_NETWORK_UNREACHABLE:         return UV_ENETUNREACH;
-    case WSAENETUNREACH:                    return UV_ENETUNREACH;
-    case WSAENOBUFS:                        return UV_ENOBUFS;
-    case ERROR_BAD_PATHNAME:                return UV_ENOENT;
-    case ERROR_DIRECTORY:                   return UV_ENOENT;
-    case ERROR_FILE_NOT_FOUND:              return UV_ENOENT;
-    case ERROR_INVALID_NAME:                return UV_ENOENT;
-    case ERROR_INVALID_DRIVE:               return UV_ENOENT;
-    case ERROR_INVALID_REPARSE_DATA:        return UV_ENOENT;
-    case ERROR_MOD_NOT_FOUND:               return UV_ENOENT;
-    case ERROR_PATH_NOT_FOUND:              return UV_ENOENT;
-    case WSAHOST_NOT_FOUND:                 return UV_ENOENT;
-    case WSANO_DATA:                        return UV_ENOENT;
-    case ERROR_NOT_ENOUGH_MEMORY:           return UV_ENOMEM;
-    case ERROR_OUTOFMEMORY:                 return UV_ENOMEM;
-    case ERROR_CANNOT_MAKE:                 return UV_ENOSPC;
-    case ERROR_DISK_FULL:                   return UV_ENOSPC;
-    case ERROR_EA_TABLE_FULL:               return UV_ENOSPC;
-    case ERROR_END_OF_MEDIA:                return UV_ENOSPC;
-    case ERROR_HANDLE_DISK_FULL:            return UV_ENOSPC;
-    case ERROR_NOT_CONNECTED:               return UV_ENOTCONN;
-    case WSAENOTCONN:                       return UV_ENOTCONN;
-    case ERROR_DIR_NOT_EMPTY:               return UV_ENOTEMPTY;
-    case WSAENOTSOCK:                       return UV_ENOTSOCK;
-    case ERROR_NOT_SUPPORTED:               return UV_ENOTSUP;
-    case ERROR_BROKEN_PIPE:                 return UV_EOF;
-    case ERROR_ACCESS_DENIED:               return UV_EPERM;
-    case ERROR_PRIVILEGE_NOT_HELD:          return UV_EPERM;
-    case ERROR_BAD_PIPE:                    return UV_EPIPE;
-    case ERROR_NO_DATA:                     return UV_EPIPE;
-    case ERROR_PIPE_NOT_CONNECTED:          return UV_EPIPE;
-    case WSAESHUTDOWN:                      return UV_EPIPE;
-    case WSAEPROTONOSUPPORT:                return UV_EPROTONOSUPPORT;
-    case ERROR_WRITE_PROTECT:               return UV_EROFS;
-    case ERROR_SEM_TIMEOUT:                 return UV_ETIMEDOUT;
-    case WSAETIMEDOUT:                      return UV_ETIMEDOUT;
-    case ERROR_NOT_SAME_DEVICE:             return UV_EXDEV;
-    case ERROR_INVALID_FUNCTION:            return UV_EISDIR;
-    case ERROR_META_EXPANSION_TOO_LONG:     return UV_E2BIG;
-    default:                                return UV_UNKNOWN;
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/fs-event.cpp b/wpiutil/src/main/native/libuv/src/win/fs-event.cpp
deleted file mode 100644
index b9ec025..0000000
--- a/wpiutil/src/main/native/libuv/src/win/fs-event.cpp
+++ /dev/null
@@ -1,591 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#define _CRT_NONSTDC_NO_WARNINGS
-
-#include <assert.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-const unsigned int uv_directory_watcher_buffer_size = 4096;
-
-
-static void uv_fs_event_queue_readdirchanges(uv_loop_t* loop,
-    uv_fs_event_t* handle) {
-  assert(handle->dir_handle != INVALID_HANDLE_VALUE);
-  assert(!handle->req_pending);
-
-  memset(&(handle->req.u.io.overlapped), 0,
-         sizeof(handle->req.u.io.overlapped));
-  if (!ReadDirectoryChangesW(handle->dir_handle,
-                             handle->buffer,
-                             uv_directory_watcher_buffer_size,
-                             (handle->flags & UV_FS_EVENT_RECURSIVE) ? TRUE : FALSE,
-                             FILE_NOTIFY_CHANGE_FILE_NAME      |
-                               FILE_NOTIFY_CHANGE_DIR_NAME     |
-                               FILE_NOTIFY_CHANGE_ATTRIBUTES   |
-                               FILE_NOTIFY_CHANGE_SIZE         |
-                               FILE_NOTIFY_CHANGE_LAST_WRITE   |
-                               FILE_NOTIFY_CHANGE_LAST_ACCESS  |
-                               FILE_NOTIFY_CHANGE_CREATION     |
-                               FILE_NOTIFY_CHANGE_SECURITY,
-                             NULL,
-                             &handle->req.u.io.overlapped,
-                             NULL)) {
-    /* Make this req pending reporting an error. */
-    SET_REQ_ERROR(&handle->req, GetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)&handle->req);
-  }
-
-  handle->req_pending = 1;
-}
-
-static void uv_relative_path(const WCHAR* filename,
-                             const WCHAR* dir,
-                             WCHAR** relpath) {
-  size_t relpathlen;
-  size_t filenamelen = wcslen(filename);
-  size_t dirlen = wcslen(dir);
-  assert(!_wcsnicmp(filename, dir, dirlen));
-  if (dirlen > 0 && dir[dirlen - 1] == '\\')
-    dirlen--;
-  relpathlen = filenamelen - dirlen - 1;
-  *relpath = (WCHAR*)uv__malloc((relpathlen + 1) * sizeof(WCHAR));
-  if (!*relpath)
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  wcsncpy(*relpath, filename + dirlen + 1, relpathlen);
-  (*relpath)[relpathlen] = L'\0';
-}
-
-static int uv_split_path(const WCHAR* filename, WCHAR** dir,
-    WCHAR** file) {
-  size_t len, i;
-
-  if (filename == NULL) {
-    if (dir != NULL)
-      *dir = NULL;
-    *file = NULL;
-    return 0;
-  }
-
-  len = wcslen(filename);
-  i = len;
-  while (i > 0 && filename[--i] != '\\' && filename[i] != '/');
-
-  if (i == 0) {
-    if (dir) {
-      *dir = (WCHAR*)uv__malloc((MAX_PATH + 1) * sizeof(WCHAR));
-      if (!*dir) {
-        uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-      }
-
-      if (!GetCurrentDirectoryW(MAX_PATH, *dir)) {
-        uv__free(*dir);
-        *dir = NULL;
-        return -1;
-      }
-    }
-
-    *file = wcsdup(filename);
-  } else {
-    if (dir) {
-      *dir = (WCHAR*)uv__malloc((i + 2) * sizeof(WCHAR));
-      if (!*dir) {
-        uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-      }
-      wcsncpy(*dir, filename, i + 1);
-      (*dir)[i + 1] = L'\0';
-    }
-
-    *file = (WCHAR*)uv__malloc((len - i) * sizeof(WCHAR));
-    if (!*file) {
-      uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-    }
-    wcsncpy(*file, filename + i + 1, len - i - 1);
-    (*file)[len - i - 1] = L'\0';
-  }
-
-  return 0;
-}
-
-
-int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_FS_EVENT);
-  handle->dir_handle = INVALID_HANDLE_VALUE;
-  handle->buffer = NULL;
-  handle->req_pending = 0;
-  handle->filew = NULL;
-  handle->short_filew = NULL;
-  handle->dirw = NULL;
-
-  UV_REQ_INIT(&handle->req, UV_FS_EVENT_REQ);
-  handle->req.data = handle;
-
-  return 0;
-}
-
-
-int uv_fs_event_start(uv_fs_event_t* handle,
-                      uv_fs_event_cb cb,
-                      const char* path,
-                      unsigned int flags) {
-  int name_size, is_path_dir, size;
-  DWORD attr, last_error;
-  WCHAR* dir = NULL, *dir_to_watch, *pathw = NULL;
-  WCHAR short_path_buffer[MAX_PATH];
-  WCHAR* short_path, *long_path;
-
-  if (uv__is_active(handle))
-    return UV_EINVAL;
-
-  handle->cb = cb;
-  handle->path = uv__strdup(path);
-  if (!handle->path) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  uv__handle_start(handle);
-
-  /* Convert name to UTF16. */
-
-  name_size = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) *
-              sizeof(WCHAR);
-  pathw = (WCHAR*)uv__malloc(name_size);
-  if (!pathw) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  if (!MultiByteToWideChar(CP_UTF8,
-                           0,
-                           path,
-                           -1,
-                           pathw,
-                           name_size / sizeof(WCHAR))) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  /* Determine whether path is a file or a directory. */
-  attr = GetFileAttributesW(pathw);
-  if (attr == INVALID_FILE_ATTRIBUTES) {
-    last_error = GetLastError();
-    goto error;
-  }
-
-  is_path_dir = (attr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
-
-  if (is_path_dir) {
-     /* path is a directory, so that's the directory that we will watch. */
-
-    /* Convert to long path. */
-    size = GetLongPathNameW(pathw, NULL, 0);
-
-    if (size) {
-      long_path = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
-      if (!long_path) {
-        uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-      }
-
-      size = GetLongPathNameW(pathw, long_path, size);
-      if (size) {
-        long_path[size] = '\0';
-      } else {
-        uv__free(long_path);
-        long_path = NULL;
-      }
-
-      if (long_path) {
-        uv__free(pathw);
-        pathw = long_path;
-      }
-    }
-
-    dir_to_watch = pathw;
-  } else {
-    /*
-     * path is a file.  So we split path into dir & file parts, and
-     * watch the dir directory.
-     */
-
-    /* Convert to short path. */
-    if (GetShortPathNameW(pathw,
-                          short_path_buffer,
-                          ARRAY_SIZE(short_path_buffer))) {
-      short_path = short_path_buffer;
-    } else {
-      short_path = NULL;
-    }
-
-    if (uv_split_path(pathw, &dir, &handle->filew) != 0) {
-      last_error = GetLastError();
-      goto error;
-    }
-
-    if (uv_split_path(short_path, NULL, &handle->short_filew) != 0) {
-      last_error = GetLastError();
-      goto error;
-    }
-
-    dir_to_watch = dir;
-    uv__free(pathw);
-    pathw = NULL;
-  }
-
-  handle->dir_handle = CreateFileW(dir_to_watch,
-                                   FILE_LIST_DIRECTORY,
-                                   FILE_SHARE_READ | FILE_SHARE_DELETE |
-                                     FILE_SHARE_WRITE,
-                                   NULL,
-                                   OPEN_EXISTING,
-                                   FILE_FLAG_BACKUP_SEMANTICS |
-                                     FILE_FLAG_OVERLAPPED,
-                                   NULL);
-
-  if (dir) {
-    uv__free(dir);
-    dir = NULL;
-  }
-
-  if (handle->dir_handle == INVALID_HANDLE_VALUE) {
-    last_error = GetLastError();
-    goto error;
-  }
-
-  if (CreateIoCompletionPort(handle->dir_handle,
-                             handle->loop->iocp,
-                             (ULONG_PTR)handle,
-                             0) == NULL) {
-    last_error = GetLastError();
-    goto error;
-  }
-
-  if (!handle->buffer) {
-    handle->buffer = (char*)uv__malloc(uv_directory_watcher_buffer_size);
-  }
-  if (!handle->buffer) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  memset(&(handle->req.u.io.overlapped), 0,
-         sizeof(handle->req.u.io.overlapped));
-
-  if (!ReadDirectoryChangesW(handle->dir_handle,
-                             handle->buffer,
-                             uv_directory_watcher_buffer_size,
-                             (flags & UV_FS_EVENT_RECURSIVE) ? TRUE : FALSE,
-                             FILE_NOTIFY_CHANGE_FILE_NAME      |
-                               FILE_NOTIFY_CHANGE_DIR_NAME     |
-                               FILE_NOTIFY_CHANGE_ATTRIBUTES   |
-                               FILE_NOTIFY_CHANGE_SIZE         |
-                               FILE_NOTIFY_CHANGE_LAST_WRITE   |
-                               FILE_NOTIFY_CHANGE_LAST_ACCESS  |
-                               FILE_NOTIFY_CHANGE_CREATION     |
-                               FILE_NOTIFY_CHANGE_SECURITY,
-                             NULL,
-                             &handle->req.u.io.overlapped,
-                             NULL)) {
-    last_error = GetLastError();
-    goto error;
-  }
-
-  assert(is_path_dir ? pathw != NULL : pathw == NULL);
-  handle->dirw = pathw;
-  handle->req_pending = 1;
-  return 0;
-
-error:
-  if (handle->path) {
-    uv__free(handle->path);
-    handle->path = NULL;
-  }
-
-  if (handle->filew) {
-    uv__free(handle->filew);
-    handle->filew = NULL;
-  }
-
-  if (handle->short_filew) {
-    uv__free(handle->short_filew);
-    handle->short_filew = NULL;
-  }
-
-  uv__free(pathw);
-
-  if (handle->dir_handle != INVALID_HANDLE_VALUE) {
-    CloseHandle(handle->dir_handle);
-    handle->dir_handle = INVALID_HANDLE_VALUE;
-  }
-
-  if (handle->buffer) {
-    uv__free(handle->buffer);
-    handle->buffer = NULL;
-  }
-
-  if (uv__is_active(handle))
-    uv__handle_stop(handle);
-
-  return uv_translate_sys_error(last_error);
-}
-
-
-int uv_fs_event_stop(uv_fs_event_t* handle) {
-  if (!uv__is_active(handle))
-    return 0;
-
-  if (handle->dir_handle != INVALID_HANDLE_VALUE) {
-    CloseHandle(handle->dir_handle);
-    handle->dir_handle = INVALID_HANDLE_VALUE;
-  }
-
-  uv__handle_stop(handle);
-
-  if (handle->filew) {
-    uv__free(handle->filew);
-    handle->filew = NULL;
-  }
-
-  if (handle->short_filew) {
-    uv__free(handle->short_filew);
-    handle->short_filew = NULL;
-  }
-
-  if (handle->path) {
-    uv__free(handle->path);
-    handle->path = NULL;
-  }
-
-  if (handle->dirw) {
-    uv__free(handle->dirw);
-    handle->dirw = NULL;
-  }
-
-  return 0;
-}
-
-
-static int file_info_cmp(WCHAR* str, WCHAR* file_name, size_t file_name_len) {
-  size_t str_len;
-
-  if (str == NULL)
-    return -1;
-
-  str_len = wcslen(str);
-
-  /*
-    Since we only care about equality, return early if the strings
-    aren't the same length
-  */
-  if (str_len != (file_name_len / sizeof(WCHAR)))
-    return -1;
-
-  return _wcsnicmp(str, file_name, str_len);
-}
-
-
-void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
-    uv_fs_event_t* handle) {
-  FILE_NOTIFY_INFORMATION* file_info;
-  int err, sizew, size;
-  char* filename = NULL;
-  WCHAR* filenamew = NULL;
-  WCHAR* long_filenamew = NULL;
-  DWORD offset = 0;
-
-  assert(req->type == UV_FS_EVENT_REQ);
-  assert(handle->req_pending);
-  handle->req_pending = 0;
-
-  /* Don't report any callbacks if:
-   * - We're closing, just push the handle onto the endgame queue
-   * - We are not active, just ignore the callback
-   */
-  if (!uv__is_active(handle)) {
-    if (handle->flags & UV_HANDLE_CLOSING) {
-      uv_want_endgame(loop, (uv_handle_t*) handle);
-    }
-    return;
-  }
-
-  file_info = (FILE_NOTIFY_INFORMATION*)(handle->buffer + offset);
-
-  if (REQ_SUCCESS(req)) {
-    if (req->u.io.overlapped.InternalHigh > 0) {
-      do {
-        file_info = (FILE_NOTIFY_INFORMATION*)((char*)file_info + offset);
-        assert(!filename);
-        assert(!filenamew);
-        assert(!long_filenamew);
-
-        /*
-         * Fire the event only if we were asked to watch a directory,
-         * or if the filename filter matches.
-         */
-        if (handle->dirw ||
-            file_info_cmp(handle->filew,
-                          file_info->FileName,
-                          file_info->FileNameLength) == 0 ||
-            file_info_cmp(handle->short_filew,
-                          file_info->FileName,
-                          file_info->FileNameLength) == 0) {
-
-          if (handle->dirw) {
-            /*
-             * We attempt to resolve the long form of the file name explicitly.
-             * We only do this for file names that might still exist on disk.
-             * If this fails, we use the name given by ReadDirectoryChangesW.
-             * This may be the long form or the 8.3 short name in some cases.
-             */
-            if (file_info->Action != FILE_ACTION_REMOVED &&
-              file_info->Action != FILE_ACTION_RENAMED_OLD_NAME) {
-              /* Construct a full path to the file. */
-              size = wcslen(handle->dirw) +
-                file_info->FileNameLength / sizeof(WCHAR) + 2;
-
-              filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
-              if (!filenamew) {
-                uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-              }
-
-              _snwprintf(filenamew, size, L"%s\\%.*s", handle->dirw,
-                file_info->FileNameLength / (DWORD)sizeof(WCHAR),
-                file_info->FileName);
-
-              filenamew[size - 1] = L'\0';
-
-              /* Convert to long name. */
-              size = GetLongPathNameW(filenamew, NULL, 0);
-
-              if (size) {
-                long_filenamew = (WCHAR*)uv__malloc(size * sizeof(WCHAR));
-                if (!long_filenamew) {
-                  uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-                }
-
-                size = GetLongPathNameW(filenamew, long_filenamew, size);
-                if (size) {
-                  long_filenamew[size] = '\0';
-                } else {
-                  uv__free(long_filenamew);
-                  long_filenamew = NULL;
-                }
-              }
-
-              uv__free(filenamew);
-
-              if (long_filenamew) {
-                /* Get the file name out of the long path. */
-                uv_relative_path(long_filenamew,
-                                 handle->dirw,
-                                 &filenamew);
-                uv__free(long_filenamew);
-                long_filenamew = filenamew;
-                sizew = -1;
-              } else {
-                /* We couldn't get the long filename, use the one reported. */
-                filenamew = file_info->FileName;
-                sizew = file_info->FileNameLength / sizeof(WCHAR);
-              }
-            } else {
-              /*
-               * Removed or renamed events cannot be resolved to the long form.
-               * We therefore use the name given by ReadDirectoryChangesW.
-               * This may be the long form or the 8.3 short name in some cases.
-               */
-              filenamew = file_info->FileName;
-              sizew = file_info->FileNameLength / sizeof(WCHAR);
-            }
-          } else {
-            /* We already have the long name of the file, so just use it. */
-            filenamew = handle->filew;
-            sizew = -1;
-          }
-
-          /* Convert the filename to utf8. */
-          uv__convert_utf16_to_utf8(filenamew, sizew, &filename);
-
-          switch (file_info->Action) {
-            case FILE_ACTION_ADDED:
-            case FILE_ACTION_REMOVED:
-            case FILE_ACTION_RENAMED_OLD_NAME:
-            case FILE_ACTION_RENAMED_NEW_NAME:
-              handle->cb(handle, filename, UV_RENAME, 0);
-              break;
-
-            case FILE_ACTION_MODIFIED:
-              handle->cb(handle, filename, UV_CHANGE, 0);
-              break;
-          }
-
-          uv__free(filename);
-          filename = NULL;
-          uv__free(long_filenamew);
-          long_filenamew = NULL;
-          filenamew = NULL;
-        }
-
-        offset = file_info->NextEntryOffset;
-      } while (offset && !(handle->flags & UV_HANDLE_CLOSING));
-    } else {
-      handle->cb(handle, NULL, UV_CHANGE, 0);
-    }
-  } else {
-    err = GET_REQ_ERROR(req);
-    handle->cb(handle, NULL, 0, uv_translate_sys_error(err));
-  }
-
-  if (!(handle->flags & UV_HANDLE_CLOSING)) {
-    uv_fs_event_queue_readdirchanges(loop, handle);
-  } else {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-}
-
-
-void uv_fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle) {
-  uv_fs_event_stop(handle);
-
-  uv__handle_closing(handle);
-
-  if (!handle->req_pending) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-
-}
-
-
-void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {
-  if ((handle->flags & UV_HANDLE_CLOSING) && !handle->req_pending) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-    if (handle->buffer) {
-      uv__free(handle->buffer);
-      handle->buffer = NULL;
-    }
-
-    uv__handle_close(handle);
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/fs.cpp b/wpiutil/src/main/native/libuv/src/win/fs.cpp
deleted file mode 100644
index 6b9e37b..0000000
--- a/wpiutil/src/main/native/libuv/src/win/fs.cpp
+++ /dev/null
@@ -1,2721 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#define _CRT_NONSTDC_NO_WARNINGS
-
-#include <assert.h>
-#include <stdlib.h>
-#include <direct.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <io.h>
-#include <limits.h>
-#include <sys/stat.h>
-#include <sys/utime.h>
-#include <stdio.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "req-inl.h"
-#include "handle-inl.h"
-
-#include <wincrypt.h>
-
-#pragma comment(lib, "Advapi32.lib")
-
-#define UV_FS_FREE_PATHS         0x0002
-#define UV_FS_FREE_PTR           0x0008
-#define UV_FS_CLEANEDUP          0x0010
-
-
-#define INIT(subtype)                                                         \
-  do {                                                                        \
-    if (req == NULL)                                                          \
-      return UV_EINVAL;                                                       \
-    uv_fs_req_init(loop, req, subtype, cb);                                   \
-  }                                                                           \
-  while (0)
-
-#define POST                                                                  \
-  do {                                                                        \
-    if (cb != NULL) {                                                         \
-      uv__req_register(loop, req);                                            \
-      uv__work_submit(loop,                                                   \
-                      &req->work_req,                                         \
-                      UV__WORK_FAST_IO,                                       \
-                      uv__fs_work,                                            \
-                      uv__fs_done);                                           \
-      return 0;                                                               \
-    } else {                                                                  \
-      uv__fs_work(&req->work_req);                                            \
-      return req->result;                                                     \
-    }                                                                         \
-  }                                                                           \
-  while (0)
-
-#define SET_REQ_RESULT(req, result_value)                                   \
-  do {                                                                      \
-    req->result = (result_value);                                           \
-    if (req->result == -1) {                                                \
-      req->sys_errno_ = _doserrno;                                          \
-      req->result = uv_translate_sys_error(req->sys_errno_);                \
-    }                                                                       \
-  } while (0)
-
-#define SET_REQ_WIN32_ERROR(req, sys_errno)                                 \
-  do {                                                                      \
-    req->sys_errno_ = (sys_errno);                                          \
-    req->result = uv_translate_sys_error(req->sys_errno_);                  \
-  } while (0)
-
-#define SET_REQ_UV_ERROR(req, uv_errno, sys_errno)                          \
-  do {                                                                      \
-    req->result = (uv_errno);                                               \
-    req->sys_errno_ = (sys_errno);                                          \
-  } while (0)
-
-#define VERIFY_FD(fd, req)                                                  \
-  if (fd == -1) {                                                           \
-    req->result = UV_EBADF;                                                 \
-    req->sys_errno_ = ERROR_INVALID_HANDLE;                                 \
-    return;                                                                 \
-  }
-
-#define MILLIONu (1000U * 1000U)
-#define BILLIONu (1000U * 1000U * 1000U)
-
-#define FILETIME_TO_UINT(filetime)                                          \
-   (*((uint64_t*) &(filetime)) - (uint64_t) 116444736 * BILLIONu)
-
-#define FILETIME_TO_TIME_T(filetime)                                        \
-   (FILETIME_TO_UINT(filetime) / (10u * MILLIONu))
-
-#define FILETIME_TO_TIME_NS(filetime, secs)                                 \
-   ((FILETIME_TO_UINT(filetime) - (secs * (uint64_t) 10 * MILLIONu)) * 100U)
-
-#define FILETIME_TO_TIMESPEC(ts, filetime)                                  \
-   do {                                                                     \
-     (ts).tv_sec = (long) FILETIME_TO_TIME_T(filetime);                     \
-     (ts).tv_nsec = (long) FILETIME_TO_TIME_NS(filetime, (ts).tv_sec);      \
-   } while(0)
-
-#define TIME_T_TO_FILETIME(time, filetime_ptr)                              \
-  do {                                                                      \
-    uint64_t bigtime = ((uint64_t) ((time) * (uint64_t) 10 * MILLIONu)) +   \
-                       (uint64_t) 116444736 * BILLIONu;                     \
-    (filetime_ptr)->dwLowDateTime = bigtime & 0xFFFFFFFF;                   \
-    (filetime_ptr)->dwHighDateTime = bigtime >> 32;                         \
-  } while(0)
-
-#define IS_SLASH(c) ((c) == L'\\' || (c) == L'/')
-#define IS_LETTER(c) (((c) >= L'a' && (c) <= L'z') || \
-  ((c) >= L'A' && (c) <= L'Z'))
-
-const WCHAR JUNCTION_PREFIX[] = L"\\??\\";
-const WCHAR JUNCTION_PREFIX_LEN = 4;
-
-const WCHAR LONG_PATH_PREFIX[] = L"\\\\?\\";
-const WCHAR LONG_PATH_PREFIX_LEN = 4;
-
-const WCHAR UNC_PATH_PREFIX[] = L"\\\\?\\UNC\\";
-const WCHAR UNC_PATH_PREFIX_LEN = 8;
-
-static int uv__file_symlink_usermode_flag = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
-
-void uv_fs_init(void) {
-  _fmode = _O_BINARY;
-}
-
-
-INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
-    const char* new_path, const int copy_path) {
-  char* buf;
-  char* pos;
-  ssize_t buf_sz = 0, path_len = 0, pathw_len = 0, new_pathw_len = 0;
-
-  /* new_path can only be set if path is also set. */
-  assert(new_path == NULL || path != NULL);
-
-  if (path != NULL) {
-    pathw_len = MultiByteToWideChar(CP_UTF8,
-                                    0,
-                                    path,
-                                    -1,
-                                    NULL,
-                                    0);
-    if (pathw_len == 0) {
-      return GetLastError();
-    }
-
-    buf_sz += pathw_len * sizeof(WCHAR);
-  }
-
-  if (path != NULL && copy_path) {
-    path_len = 1 + strlen(path);
-    buf_sz += path_len;
-  }
-
-  if (new_path != NULL) {
-    new_pathw_len = MultiByteToWideChar(CP_UTF8,
-                                        0,
-                                        new_path,
-                                        -1,
-                                        NULL,
-                                        0);
-    if (new_pathw_len == 0) {
-      return GetLastError();
-    }
-
-    buf_sz += new_pathw_len * sizeof(WCHAR);
-  }
-
-
-  if (buf_sz == 0) {
-    req->file.pathw = NULL;
-    req->fs.info.new_pathw = NULL;
-    req->path = NULL;
-    return 0;
-  }
-
-  buf = (char*) uv__malloc(buf_sz);
-  if (buf == NULL) {
-    return ERROR_OUTOFMEMORY;
-  }
-
-  pos = buf;
-
-  if (path != NULL) {
-    DWORD r = MultiByteToWideChar(CP_UTF8,
-                                  0,
-                                  path,
-                                  -1,
-                                  (WCHAR*) pos,
-                                  pathw_len);
-    assert(r == (DWORD) pathw_len);
-    req->file.pathw = (WCHAR*) pos;
-    pos += r * sizeof(WCHAR);
-  } else {
-    req->file.pathw = NULL;
-  }
-
-  if (new_path != NULL) {
-    DWORD r = MultiByteToWideChar(CP_UTF8,
-                                  0,
-                                  new_path,
-                                  -1,
-                                  (WCHAR*) pos,
-                                  new_pathw_len);
-    assert(r == (DWORD) new_pathw_len);
-    req->fs.info.new_pathw = (WCHAR*) pos;
-    pos += r * sizeof(WCHAR);
-  } else {
-    req->fs.info.new_pathw = NULL;
-  }
-
-  req->path = path;
-  if (path != NULL && copy_path) {
-    memcpy(pos, path, path_len);
-    assert(path_len == buf_sz - (pos - buf));
-    req->path = pos;
-  }
-
-  req->flags |= UV_FS_FREE_PATHS;
-
-  return 0;
-}
-
-
-
-INLINE static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req,
-    uv_fs_type fs_type, const uv_fs_cb cb) {
-  uv__once_init();
-  UV_REQ_INIT(req, UV_FS);
-  req->loop = loop;
-  req->flags = 0;
-  req->fs_type = fs_type;
-  req->result = 0;
-  req->ptr = NULL;
-  req->path = NULL;
-  req->cb = cb;
-  memset(&req->fs, 0, sizeof(req->fs));
-}
-
-
-static int fs__wide_to_utf8(WCHAR* w_source_ptr,
-                               DWORD w_source_len,
-                               char** target_ptr,
-                               uint64_t* target_len_ptr) {
-  int r;
-  int target_len;
-  char* target;
-  target_len = WideCharToMultiByte(CP_UTF8,
-                                   0,
-                                   w_source_ptr,
-                                   w_source_len,
-                                   NULL,
-                                   0,
-                                   NULL,
-                                   NULL);
-
-  if (target_len == 0) {
-    return -1;
-  }
-
-  if (target_len_ptr != NULL) {
-    *target_len_ptr = target_len;
-  }
-
-  if (target_ptr == NULL) {
-    return 0;
-  }
-
-  target = (char*)uv__malloc(target_len + 1);
-  if (target == NULL) {
-    SetLastError(ERROR_OUTOFMEMORY);
-    return -1;
-  }
-
-  r = WideCharToMultiByte(CP_UTF8,
-                          0,
-                          w_source_ptr,
-                          w_source_len,
-                          target,
-                          target_len,
-                          NULL,
-                          NULL);
-  assert(r == target_len);
-  target[target_len] = '\0';
-  *target_ptr = target;
-  return 0;
-}
-
-
-INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr,
-    uint64_t* target_len_ptr) {
-  char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
-  REPARSE_DATA_BUFFER* reparse_data = (REPARSE_DATA_BUFFER*) buffer;
-  WCHAR* w_target;
-  DWORD w_target_len;
-  DWORD bytes;
-
-  if (!DeviceIoControl(handle,
-                       FSCTL_GET_REPARSE_POINT,
-                       NULL,
-                       0,
-                       buffer,
-                       sizeof buffer,
-                       &bytes,
-                       NULL)) {
-    return -1;
-  }
-
-  if (reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK) {
-    /* Real symlink */
-    w_target = reparse_data->SymbolicLinkReparseBuffer.PathBuffer +
-        (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset /
-        sizeof(WCHAR));
-    w_target_len =
-        reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength /
-        sizeof(WCHAR);
-
-    /* Real symlinks can contain pretty much everything, but the only thing we
-     * really care about is undoing the implicit conversion to an NT namespaced
-     * path that CreateSymbolicLink will perform on absolute paths. If the path
-     * is win32-namespaced then the user must have explicitly made it so, and
-     * we better just return the unmodified reparse data. */
-    if (w_target_len >= 4 &&
-        w_target[0] == L'\\' &&
-        w_target[1] == L'?' &&
-        w_target[2] == L'?' &&
-        w_target[3] == L'\\') {
-      /* Starts with \??\ */
-      if (w_target_len >= 6 &&
-          ((w_target[4] >= L'A' && w_target[4] <= L'Z') ||
-           (w_target[4] >= L'a' && w_target[4] <= L'z')) &&
-          w_target[5] == L':' &&
-          (w_target_len == 6 || w_target[6] == L'\\')) {
-        /* \??\<drive>:\ */
-        w_target += 4;
-        w_target_len -= 4;
-
-      } else if (w_target_len >= 8 &&
-                 (w_target[4] == L'U' || w_target[4] == L'u') &&
-                 (w_target[5] == L'N' || w_target[5] == L'n') &&
-                 (w_target[6] == L'C' || w_target[6] == L'c') &&
-                 w_target[7] == L'\\') {
-        /* \??\UNC\<server>\<share>\ - make sure the final path looks like
-         * \\<server>\<share>\ */
-        w_target += 6;
-        w_target[0] = L'\\';
-        w_target_len -= 6;
-      }
-    }
-
-  } else if (reparse_data->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) {
-    /* Junction. */
-    w_target = reparse_data->MountPointReparseBuffer.PathBuffer +
-        (reparse_data->MountPointReparseBuffer.SubstituteNameOffset /
-        sizeof(WCHAR));
-    w_target_len = reparse_data->MountPointReparseBuffer.SubstituteNameLength /
-        sizeof(WCHAR);
-
-    /* Only treat junctions that look like \??\<drive>:\ as symlink. Junctions
-     * can also be used as mount points, like \??\Volume{<guid>}, but that's
-     * confusing for programs since they wouldn't be able to actually
-     * understand such a path when returned by uv_readlink(). UNC paths are
-     * never valid for junctions so we don't care about them. */
-    if (!(w_target_len >= 6 &&
-          w_target[0] == L'\\' &&
-          w_target[1] == L'?' &&
-          w_target[2] == L'?' &&
-          w_target[3] == L'\\' &&
-          ((w_target[4] >= L'A' && w_target[4] <= L'Z') ||
-           (w_target[4] >= L'a' && w_target[4] <= L'z')) &&
-          w_target[5] == L':' &&
-          (w_target_len == 6 || w_target[6] == L'\\'))) {
-      SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);
-      return -1;
-    }
-
-    /* Remove leading \??\ */
-    w_target += 4;
-    w_target_len -= 4;
-
-  } else {
-    /* Reparse tag does not indicate a symlink. */
-    SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);
-    return -1;
-  }
-
-  return fs__wide_to_utf8(w_target, w_target_len, target_ptr, target_len_ptr);
-}
-
-
-void fs__open(uv_fs_t* req) {
-  DWORD access;
-  DWORD share;
-  DWORD disposition;
-  DWORD attributes = 0;
-  HANDLE file;
-  int fd, current_umask;
-  int flags = req->fs.info.file_flags;
-
-  /* Obtain the active umask. umask() never fails and returns the previous
-   * umask. */
-  current_umask = umask(0);
-  umask(current_umask);
-
-  /* convert flags and mode to CreateFile parameters */
-  switch (flags & (UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR)) {
-  case UV_FS_O_RDONLY:
-    access = FILE_GENERIC_READ;
-    break;
-  case UV_FS_O_WRONLY:
-    access = FILE_GENERIC_WRITE;
-    break;
-  case UV_FS_O_RDWR:
-    access = FILE_GENERIC_READ | FILE_GENERIC_WRITE;
-    break;
-  default:
-    goto einval;
-  }
-
-  if (flags & UV_FS_O_APPEND) {
-    access &= ~FILE_WRITE_DATA;
-    access |= FILE_APPEND_DATA;
-  }
-
-  /*
-   * Here is where we deviate significantly from what CRT's _open()
-   * does. We indiscriminately use all the sharing modes, to match
-   * UNIX semantics. In particular, this ensures that the file can
-   * be deleted even whilst it's open, fixing issue #1449.
-   * We still support exclusive sharing mode, since it is necessary
-   * for opening raw block devices, otherwise Windows will prevent
-   * any attempt to write past the master boot record.
-   */
-  if (flags & UV_FS_O_EXLOCK) {
-    share = 0;
-  } else {
-    share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
-  }
-
-  switch (flags & (UV_FS_O_CREAT | UV_FS_O_EXCL | UV_FS_O_TRUNC)) {
-  case 0:
-  case UV_FS_O_EXCL:
-    disposition = OPEN_EXISTING;
-    break;
-  case UV_FS_O_CREAT:
-    disposition = OPEN_ALWAYS;
-    break;
-  case UV_FS_O_CREAT | UV_FS_O_EXCL:
-  case UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL:
-    disposition = CREATE_NEW;
-    break;
-  case UV_FS_O_TRUNC:
-  case UV_FS_O_TRUNC | UV_FS_O_EXCL:
-    disposition = TRUNCATE_EXISTING;
-    break;
-  case UV_FS_O_CREAT | UV_FS_O_TRUNC:
-    disposition = CREATE_ALWAYS;
-    break;
-  default:
-    goto einval;
-  }
-
-  attributes |= FILE_ATTRIBUTE_NORMAL;
-  if (flags & UV_FS_O_CREAT) {
-    if (!((req->fs.info.mode & ~current_umask) & _S_IWRITE)) {
-      attributes |= FILE_ATTRIBUTE_READONLY;
-    }
-  }
-
-  if (flags & UV_FS_O_TEMPORARY ) {
-    attributes |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
-    access |= DELETE;
-  }
-
-  if (flags & UV_FS_O_SHORT_LIVED) {
-    attributes |= FILE_ATTRIBUTE_TEMPORARY;
-  }
-
-  switch (flags & (UV_FS_O_SEQUENTIAL | UV_FS_O_RANDOM)) {
-  case 0:
-    break;
-  case UV_FS_O_SEQUENTIAL:
-    attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
-    break;
-  case UV_FS_O_RANDOM:
-    attributes |= FILE_FLAG_RANDOM_ACCESS;
-    break;
-  default:
-    goto einval;
-  }
-
-  if (flags & UV_FS_O_DIRECT) {
-    /*
-     * FILE_APPEND_DATA and FILE_FLAG_NO_BUFFERING are mutually exclusive.
-     * Windows returns 87, ERROR_INVALID_PARAMETER if these are combined.
-     *
-     * FILE_APPEND_DATA is included in FILE_GENERIC_WRITE:
-     *
-     * FILE_GENERIC_WRITE = STANDARD_RIGHTS_WRITE |
-     *                      FILE_WRITE_DATA |
-     *                      FILE_WRITE_ATTRIBUTES |
-     *                      FILE_WRITE_EA |
-     *                      FILE_APPEND_DATA |
-     *                      SYNCHRONIZE
-     *
-     * Note: Appends are also permitted by FILE_WRITE_DATA.
-     *
-     * In order for direct writes and direct appends to succeed, we therefore
-     * exclude FILE_APPEND_DATA if FILE_WRITE_DATA is specified, and otherwise
-     * fail if the user's sole permission is a direct append, since this
-     * particular combination is invalid.
-     */
-    if (access & FILE_APPEND_DATA) {
-      if (access & FILE_WRITE_DATA) {
-        access &= ~FILE_APPEND_DATA;
-      } else {
-        goto einval;
-      }
-    }
-    attributes |= FILE_FLAG_NO_BUFFERING;
-  }
-
-  switch (flags & (UV_FS_O_DSYNC | UV_FS_O_SYNC)) {
-  case 0:
-    break;
-  case UV_FS_O_DSYNC:
-  case UV_FS_O_SYNC:
-    attributes |= FILE_FLAG_WRITE_THROUGH;
-    break;
-  default:
-    goto einval;
-  }
-
-  /* Setting this flag makes it possible to open a directory. */
-  attributes |= FILE_FLAG_BACKUP_SEMANTICS;
-
-  file = CreateFileW(req->file.pathw,
-                     access,
-                     share,
-                     NULL,
-                     disposition,
-                     attributes,
-                     NULL);
-  if (file == INVALID_HANDLE_VALUE) {
-    DWORD error = GetLastError();
-    if (error == ERROR_FILE_EXISTS && (flags & UV_FS_O_CREAT) &&
-        !(flags & UV_FS_O_EXCL)) {
-      /* Special case: when ERROR_FILE_EXISTS happens and UV_FS_O_CREAT was
-       * specified, it means the path referred to a directory. */
-      SET_REQ_UV_ERROR(req, UV_EISDIR, error);
-    } else {
-      SET_REQ_WIN32_ERROR(req, GetLastError());
-    }
-    return;
-  }
-
-  fd = _open_osfhandle((intptr_t) file, flags);
-  if (fd < 0) {
-    /* The only known failure mode for _open_osfhandle() is EMFILE, in which
-     * case GetLastError() will return zero. However we'll try to handle other
-     * errors as well, should they ever occur.
-     */
-    if (errno == EMFILE)
-      SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);
-    else if (GetLastError() != ERROR_SUCCESS)
-      SET_REQ_WIN32_ERROR(req, GetLastError());
-    else
-      SET_REQ_WIN32_ERROR(req, UV_UNKNOWN);
-    CloseHandle(file);
-    return;
-  }
-
-  SET_REQ_RESULT(req, fd);
-  return;
-
- einval:
-  SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
-}
-
-void fs__close(uv_fs_t* req) {
-  int fd = req->file.fd;
-  int result;
-
-  VERIFY_FD(fd, req);
-
-  if (fd > 2)
-    result = _close(fd);
-  else
-    result = 0;
-
-  /* _close doesn't set _doserrno on failure, but it does always set errno
-   * to EBADF on failure.
-   */
-  if (result == -1) {
-    assert(errno == EBADF);
-    SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE);
-  } else {
-    req->result = 0;
-  }
-}
-
-
-void fs__read(uv_fs_t* req) {
-  int fd = req->file.fd;
-  int64_t offset = req->fs.info.offset;
-  HANDLE handle;
-  OVERLAPPED overlapped, *overlapped_ptr;
-  LARGE_INTEGER offset_;
-  DWORD bytes;
-  DWORD error;
-  int result;
-  unsigned int index;
-  LARGE_INTEGER original_position;
-  LARGE_INTEGER zero_offset;
-  int restore_position;
-
-  VERIFY_FD(fd, req);
-
-  zero_offset.QuadPart = 0;
-  restore_position = 0;
-  handle = uv__get_osfhandle(fd);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
-    return;
-  }
-
-  if (offset != -1) {
-    memset(&overlapped, 0, sizeof overlapped);
-    overlapped_ptr = &overlapped;
-    if (SetFilePointerEx(handle, zero_offset, &original_position,
-                         FILE_CURRENT)) {
-      restore_position = 1;
-    }
-  } else {
-    overlapped_ptr = NULL;
-  }
-
-  index = 0;
-  bytes = 0;
-  do {
-    DWORD incremental_bytes;
-
-    if (offset != -1) {
-      offset_.QuadPart = offset + bytes;
-      overlapped.Offset = offset_.LowPart;
-      overlapped.OffsetHigh = offset_.HighPart;
-    }
-
-    result = ReadFile(handle,
-                      req->fs.info.bufs[index].base,
-                      req->fs.info.bufs[index].len,
-                      &incremental_bytes,
-                      overlapped_ptr);
-    bytes += incremental_bytes;
-    ++index;
-  } while (result && index < req->fs.info.nbufs);
-
-  if (restore_position)
-    SetFilePointerEx(handle, original_position, NULL, FILE_BEGIN);
-
-  if (result || bytes > 0) {
-    SET_REQ_RESULT(req, bytes);
-  } else {
-    error = GetLastError();
-    if (error == ERROR_HANDLE_EOF) {
-      SET_REQ_RESULT(req, bytes);
-    } else {
-      SET_REQ_WIN32_ERROR(req, error);
-    }
-  }
-}
-
-
-void fs__write(uv_fs_t* req) {
-  int fd = req->file.fd;
-  int64_t offset = req->fs.info.offset;
-  HANDLE handle;
-  OVERLAPPED overlapped, *overlapped_ptr;
-  LARGE_INTEGER offset_;
-  DWORD bytes;
-  int result;
-  unsigned int index;
-  LARGE_INTEGER original_position;
-  LARGE_INTEGER zero_offset;
-  int restore_position;
-
-  VERIFY_FD(fd, req);
-
-  zero_offset.QuadPart = 0;
-  restore_position = 0;
-  handle = uv__get_osfhandle(fd);
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
-    return;
-  }
-
-  if (offset != -1) {
-    memset(&overlapped, 0, sizeof overlapped);
-    overlapped_ptr = &overlapped;
-    if (SetFilePointerEx(handle, zero_offset, &original_position,
-                         FILE_CURRENT)) {
-      restore_position = 1;
-    }
-  } else {
-    overlapped_ptr = NULL;
-  }
-
-  index = 0;
-  bytes = 0;
-  do {
-    DWORD incremental_bytes;
-
-    if (offset != -1) {
-      offset_.QuadPart = offset + bytes;
-      overlapped.Offset = offset_.LowPart;
-      overlapped.OffsetHigh = offset_.HighPart;
-    }
-
-    result = WriteFile(handle,
-                       req->fs.info.bufs[index].base,
-                       req->fs.info.bufs[index].len,
-                       &incremental_bytes,
-                       overlapped_ptr);
-    bytes += incremental_bytes;
-    ++index;
-  } while (result && index < req->fs.info.nbufs);
-
-  if (restore_position)
-    SetFilePointerEx(handle, original_position, NULL, FILE_BEGIN);
-
-  if (result || bytes > 0) {
-    SET_REQ_RESULT(req, bytes);
-  } else {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-  }
-}
-
-
-void fs__rmdir(uv_fs_t* req) {
-  int result = _wrmdir(req->file.pathw);
-  SET_REQ_RESULT(req, result);
-}
-
-
-void fs__unlink(uv_fs_t* req) {
-  const WCHAR* pathw = req->file.pathw;
-  HANDLE handle;
-  BY_HANDLE_FILE_INFORMATION info;
-  FILE_DISPOSITION_INFORMATION disposition;
-  IO_STATUS_BLOCK iosb;
-  NTSTATUS status;
-
-  handle = CreateFileW(pathw,
-                       FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | DELETE,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                       NULL,
-                       OPEN_EXISTING,
-                       FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
-                       NULL);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  if (!GetFileInformationByHandle(handle, &info)) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    CloseHandle(handle);
-    return;
-  }
-
-  if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-    /* Do not allow deletion of directories, unless it is a symlink. When the
-     * path refers to a non-symlink directory, report EPERM as mandated by
-     * POSIX.1. */
-
-    /* Check if it is a reparse point. If it's not, it's a normal directory. */
-    if (!(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
-      SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);
-      CloseHandle(handle);
-      return;
-    }
-
-    /* Read the reparse point and check if it is a valid symlink. If not, don't
-     * unlink. */
-    if (fs__readlink_handle(handle, NULL, NULL) < 0) {
-      DWORD error = GetLastError();
-      if (error == ERROR_SYMLINK_NOT_SUPPORTED)
-        error = ERROR_ACCESS_DENIED;
-      SET_REQ_WIN32_ERROR(req, error);
-      CloseHandle(handle);
-      return;
-    }
-  }
-
-  if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
-    /* Remove read-only attribute */
-    FILE_BASIC_INFORMATION basic = { 0 };
-
-    basic.FileAttributes = (info.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY) |
-                           FILE_ATTRIBUTE_ARCHIVE;
-
-    status = pNtSetInformationFile(handle,
-                                   &iosb,
-                                   &basic,
-                                   sizeof basic,
-                                   FileBasicInformation);
-    if (!NT_SUCCESS(status)) {
-      SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
-      CloseHandle(handle);
-      return;
-    }
-  }
-
-  /* Try to set the delete flag. */
-  disposition.DeleteFile = TRUE;
-  status = pNtSetInformationFile(handle,
-                                 &iosb,
-                                 &disposition,
-                                 sizeof disposition,
-                                 FileDispositionInformation);
-  if (NT_SUCCESS(status)) {
-    SET_REQ_SUCCESS(req);
-  } else {
-    SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
-  }
-
-  CloseHandle(handle);
-}
-
-
-void fs__mkdir(uv_fs_t* req) {
-  /* TODO: use req->mode. */
-  int result = _wmkdir(req->file.pathw);
-  SET_REQ_RESULT(req, result);
-}
-
-
-/* OpenBSD original: lib/libc/stdio/mktemp.c */
-void fs__mkdtemp(uv_fs_t* req) {
-  static const WCHAR *tempchars =
-    L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  static const size_t num_chars = 62;
-  static const size_t num_x = 6;
-  WCHAR *cp, *ep;
-  unsigned int tries, i;
-  size_t len;
-  HCRYPTPROV h_crypt_prov;
-  uint64_t v;
-  BOOL released;
-
-  len = wcslen(req->file.pathw);
-  ep = req->file.pathw + len;
-  if (len < num_x || wcsncmp(ep - num_x, L"XXXXXX", num_x)) {
-    SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
-    return;
-  }
-
-  if (!CryptAcquireContext(&h_crypt_prov, NULL, NULL, PROV_RSA_FULL,
-                           CRYPT_VERIFYCONTEXT)) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  tries = TMP_MAX;
-  do {
-    if (!CryptGenRandom(h_crypt_prov, sizeof(v), (BYTE*) &v)) {
-      SET_REQ_WIN32_ERROR(req, GetLastError());
-      break;
-    }
-
-    cp = ep - num_x;
-    for (i = 0; i < num_x; i++) {
-      *cp++ = tempchars[v % num_chars];
-      v /= num_chars;
-    }
-
-    if (_wmkdir(req->file.pathw) == 0) {
-      len = strlen(req->path);
-      wcstombs((char*) req->path + len - num_x, ep - num_x, num_x);
-      SET_REQ_RESULT(req, 0);
-      break;
-    } else if (errno != EEXIST) {
-      SET_REQ_RESULT(req, -1);
-      break;
-    }
-  } while (--tries);
-
-  released = CryptReleaseContext(h_crypt_prov, 0);
-  assert(released);
-  if (tries == 0) {
-    SET_REQ_RESULT(req, -1);
-  }
-}
-
-
-void fs__scandir(uv_fs_t* req) {
-  static const size_t dirents_initial_size = 32;
-
-  HANDLE dir_handle = INVALID_HANDLE_VALUE;
-
-  uv__dirent_t** dirents = NULL;
-  size_t dirents_size = 0;
-  size_t dirents_used = 0;
-
-  IO_STATUS_BLOCK iosb;
-  NTSTATUS status;
-
-  /* Buffer to hold directory entries returned by NtQueryDirectoryFile.
-   * It's important that this buffer can hold at least one entry, regardless
-   * of the length of the file names present in the enumerated directory.
-   * A file name is at most 256 WCHARs long.
-   * According to MSDN, the buffer must be aligned at an 8-byte boundary.
-   */
-#if _MSC_VER
-  __declspec(align(8)) char buffer[8192];
-#else
-  __attribute__ ((aligned (8))) char buffer[8192];
-#endif
-
-  STATIC_ASSERT(sizeof buffer >=
-                sizeof(FILE_DIRECTORY_INFORMATION) + 256 * sizeof(WCHAR));
-
-  /* Open the directory. */
-  dir_handle =
-      CreateFileW(req->file.pathw,
-                  FILE_LIST_DIRECTORY | SYNCHRONIZE,
-                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                  NULL,
-                  OPEN_EXISTING,
-                  FILE_FLAG_BACKUP_SEMANTICS,
-                  NULL);
-  if (dir_handle == INVALID_HANDLE_VALUE)
-    goto win32_error;
-
-  /* Read the first chunk. */
-  status = pNtQueryDirectoryFile(dir_handle,
-                                 NULL,
-                                 NULL,
-                                 NULL,
-                                 &iosb,
-                                 &buffer,
-                                 sizeof buffer,
-                                 FileDirectoryInformation,
-                                 FALSE,
-                                 NULL,
-                                 TRUE);
-
-  /* If the handle is not a directory, we'll get STATUS_INVALID_PARAMETER.
-   * This should be reported back as UV_ENOTDIR.
-   */
-  if (status == STATUS_INVALID_PARAMETER)
-    goto not_a_directory_error;
-
-  while (NT_SUCCESS(status)) {
-    char* position = buffer;
-    size_t next_entry_offset = 0;
-
-    do {
-      FILE_DIRECTORY_INFORMATION* info;
-      uv__dirent_t* dirent;
-
-      size_t wchar_len;
-      size_t utf8_len;
-
-      /* Obtain a pointer to the current directory entry. */
-      position += next_entry_offset;
-      info = (FILE_DIRECTORY_INFORMATION*) position;
-
-      /* Fetch the offset to the next directory entry. */
-      next_entry_offset = info->NextEntryOffset;
-
-      /* Compute the length of the filename in WCHARs. */
-      wchar_len = info->FileNameLength / sizeof info->FileName[0];
-
-      /* Skip over '.' and '..' entries.  It has been reported that
-       * the SharePoint driver includes the terminating zero byte in
-       * the filename length.  Strip those first.
-       */
-      while (wchar_len > 0 && info->FileName[wchar_len - 1] == L'\0')
-        wchar_len -= 1;
-
-      if (wchar_len == 0)
-        continue;
-      if (wchar_len == 1 && info->FileName[0] == L'.')
-        continue;
-      if (wchar_len == 2 && info->FileName[0] == L'.' &&
-          info->FileName[1] == L'.')
-        continue;
-
-      /* Compute the space required to store the filename as UTF-8. */
-      utf8_len = WideCharToMultiByte(
-          CP_UTF8, 0, &info->FileName[0], wchar_len, NULL, 0, NULL, NULL);
-      if (utf8_len == 0)
-        goto win32_error;
-
-      /* Resize the dirent array if needed. */
-      if (dirents_used >= dirents_size) {
-        size_t new_dirents_size =
-            dirents_size == 0 ? dirents_initial_size : dirents_size << 1;
-        uv__dirent_t** new_dirents = (uv__dirent_t**)
-            uv__realloc(dirents, new_dirents_size * sizeof *dirents);
-
-        if (new_dirents == NULL)
-          goto out_of_memory_error;
-
-        dirents_size = new_dirents_size;
-        dirents = new_dirents;
-      }
-
-      /* Allocate space for the uv dirent structure. The dirent structure
-       * includes room for the first character of the filename, but `utf8_len`
-       * doesn't count the NULL terminator at this point.
-       */
-      dirent = (uv__dirent_t*)uv__malloc(sizeof *dirent + utf8_len);
-      if (dirent == NULL)
-        goto out_of_memory_error;
-
-      dirents[dirents_used++] = dirent;
-
-      /* Convert file name to UTF-8. */
-      if (WideCharToMultiByte(CP_UTF8,
-                              0,
-                              &info->FileName[0],
-                              wchar_len,
-                              &dirent->d_name[0],
-                              utf8_len,
-                              NULL,
-                              NULL) == 0)
-        goto win32_error;
-
-      /* Add a null terminator to the filename. */
-      dirent->d_name[utf8_len] = '\0';
-
-      /* Fill out the type field. */
-      if (info->FileAttributes & FILE_ATTRIBUTE_DEVICE)
-        dirent->d_type = UV__DT_CHAR;
-      else if (info->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
-        dirent->d_type = UV__DT_LINK;
-      else if (info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-        dirent->d_type = UV__DT_DIR;
-      else
-        dirent->d_type = UV__DT_FILE;
-    } while (next_entry_offset != 0);
-
-    /* Read the next chunk. */
-    status = pNtQueryDirectoryFile(dir_handle,
-                                   NULL,
-                                   NULL,
-                                   NULL,
-                                   &iosb,
-                                   &buffer,
-                                   sizeof buffer,
-                                   FileDirectoryInformation,
-                                   FALSE,
-                                   NULL,
-                                   FALSE);
-
-    /* After the first pNtQueryDirectoryFile call, the function may return
-     * STATUS_SUCCESS even if the buffer was too small to hold at least one
-     * directory entry.
-     */
-    if (status == STATUS_SUCCESS && iosb.Information == 0)
-      status = STATUS_BUFFER_OVERFLOW;
-  }
-
-  if (status != STATUS_NO_MORE_FILES)
-    goto nt_error;
-
-  CloseHandle(dir_handle);
-
-  /* Store the result in the request object. */
-  req->ptr = dirents;
-  if (dirents != NULL)
-    req->flags |= UV_FS_FREE_PTR;
-
-  SET_REQ_RESULT(req, dirents_used);
-
-  /* `nbufs` will be used as index by uv_fs_scandir_next. */
-  req->fs.info.nbufs = 0;
-
-  return;
-
-nt_error:
-  SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
-  goto cleanup;
-
-win32_error:
-  SET_REQ_WIN32_ERROR(req, GetLastError());
-  goto cleanup;
-
-not_a_directory_error:
-  SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
-  goto cleanup;
-
-out_of_memory_error:
-  SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
-  goto cleanup;
-
-cleanup:
-  if (dir_handle != INVALID_HANDLE_VALUE)
-    CloseHandle(dir_handle);
-  while (dirents_used > 0)
-    uv__free(dirents[--dirents_used]);
-  if (dirents != NULL)
-    uv__free(dirents);
-}
-
-void fs__opendir(uv_fs_t* req) {
-  WCHAR* pathw;
-  size_t len;
-  const WCHAR* fmt;
-  WCHAR* find_path;
-  uv_dir_t* dir;
-
-  pathw = req->file.pathw;
-  dir = NULL;
-  find_path = NULL;
-
-  /* Figure out whether path is a file or a directory. */
-  if (!(GetFileAttributesW(pathw) & FILE_ATTRIBUTE_DIRECTORY)) {
-    SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
-    goto error;
-  }
-
-  dir = (uv_dir_t*)uv__malloc(sizeof(*dir));
-  if (dir == NULL) {
-    SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
-    goto error;
-  }
-
-  len = wcslen(pathw);
-
-  if (len == 0)
-    fmt = L"./*";
-  else if (IS_SLASH(pathw[len - 1]))
-    fmt = L"%s*";
-  else
-    fmt = L"%s\\*";
-
-  find_path = (WCHAR*)uv__malloc(sizeof(WCHAR) * (len + 4));
-  if (find_path == NULL) {
-    SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
-    goto error;
-  }
-
-  _snwprintf(find_path, len + 3, fmt, pathw);
-  dir->dir_handle = FindFirstFileW(find_path, &dir->find_data);
-  uv__free(find_path);
-  find_path = NULL;
-  if (dir->dir_handle == INVALID_HANDLE_VALUE &&
-      GetLastError() != ERROR_FILE_NOT_FOUND) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    goto error;
-  }
-
-  dir->need_find_call = FALSE;
-  req->ptr = dir;
-  SET_REQ_RESULT(req, 0);
-  return;
-
-error:
-  uv__free(dir);
-  uv__free(find_path);
-  req->ptr = NULL;
-}
-
-void fs__readdir(uv_fs_t* req) {
-  uv_dir_t* dir;
-  uv_dirent_t* dirents;
-  uv__dirent_t dent;
-  unsigned int dirent_idx;
-  PWIN32_FIND_DATAW find_data;
-  unsigned int i;
-  int r;
-
-  req->flags |= UV_FS_FREE_PTR;
-  dir = (uv_dir_t*)req->ptr;
-  dirents = dir->dirents;
-  memset(dirents, 0, dir->nentries * sizeof(*dir->dirents));
-  find_data = &dir->find_data;
-  dirent_idx = 0;
-
-  while (dirent_idx < dir->nentries) {
-    if (dir->need_find_call && FindNextFileW(dir->dir_handle, find_data) == 0) {
-      if (GetLastError() == ERROR_NO_MORE_FILES)
-        break;
-      goto error;
-    }
-
-    /* Skip "." and ".." entries. */
-    if (find_data->cFileName[0] == L'.' &&
-        (find_data->cFileName[1] == L'\0' ||
-        (find_data->cFileName[1] == L'.' &&
-        find_data->cFileName[2] == L'\0'))) {
-      dir->need_find_call = TRUE;
-      continue;
-    }
-
-    r = uv__convert_utf16_to_utf8((const WCHAR*) &find_data->cFileName,
-                                  -1,
-                                  (char**) &dirents[dirent_idx].name);
-    if (r != 0)
-      goto error;
-
-    /* Copy file type. */
-    if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
-      dent.d_type = UV__DT_DIR;
-    else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0)
-      dent.d_type = UV__DT_LINK;
-    else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DEVICE) != 0)
-      dent.d_type = UV__DT_CHAR;
-    else
-      dent.d_type = UV__DT_FILE;
-
-    dirents[dirent_idx].type = uv__fs_get_dirent_type(&dent);
-    dir->need_find_call = TRUE;
-    ++dirent_idx;
-  }
-
-  SET_REQ_RESULT(req, dirent_idx);
-  return;
-
-error:
-  SET_REQ_WIN32_ERROR(req, GetLastError());
-  for (i = 0; i < dirent_idx; ++i) {
-    uv__free((char*) dirents[i].name);
-    dirents[i].name = NULL;
-  }
-}
-
-void fs__closedir(uv_fs_t* req) {
-  uv_dir_t* dir;
-
-  dir = (uv_dir_t*)req->ptr;
-  FindClose(dir->dir_handle);
-  uv__free(req->ptr);
-  SET_REQ_RESULT(req, 0);
-}
-
-INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf,
-    int do_lstat) {
-  FILE_ALL_INFORMATION file_info;
-  FILE_FS_VOLUME_INFORMATION volume_info;
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-
-  nt_status = pNtQueryInformationFile(handle,
-                                      &io_status,
-                                      &file_info,
-                                      sizeof file_info,
-                                      FileAllInformation);
-
-  /* Buffer overflow (a warning status code) is expected here. */
-  if (NT_ERROR(nt_status)) {
-    SetLastError(pRtlNtStatusToDosError(nt_status));
-    return -1;
-  }
-
-  nt_status = pNtQueryVolumeInformationFile(handle,
-                                            &io_status,
-                                            &volume_info,
-                                            sizeof volume_info,
-                                            FileFsVolumeInformation);
-
-  /* Buffer overflow (a warning status code) is expected here. */
-  if (io_status.Status == STATUS_NOT_IMPLEMENTED) {
-    statbuf->st_dev = 0;
-  } else if (NT_ERROR(nt_status)) {
-    SetLastError(pRtlNtStatusToDosError(nt_status));
-    return -1;
-  } else {
-    statbuf->st_dev = volume_info.VolumeSerialNumber;
-  }
-
-  /* Todo: st_mode should probably always be 0666 for everyone. We might also
-   * want to report 0777 if the file is a .exe or a directory.
-   *
-   * Currently it's based on whether the 'readonly' attribute is set, which
-   * makes little sense because the semantics are so different: the 'read-only'
-   * flag is just a way for a user to protect against accidental deletion, and
-   * serves no security purpose. Windows uses ACLs for that.
-   *
-   * Also people now use uv_fs_chmod() to take away the writable bit for good
-   * reasons. Windows however just makes the file read-only, which makes it
-   * impossible to delete the file afterwards, since read-only files can't be
-   * deleted.
-   *
-   * IOW it's all just a clusterfuck and we should think of something that
-   * makes slightly more sense.
-   *
-   * And uv_fs_chmod should probably just fail on windows or be a total no-op.
-   * There's nothing sensible it can do anyway.
-   */
-  statbuf->st_mode = 0;
-
-  /*
-  * On Windows, FILE_ATTRIBUTE_REPARSE_POINT is a general purpose mechanism
-  * by which filesystem drivers can intercept and alter file system requests.
-  *
-  * The only reparse points we care about are symlinks and mount points, both
-  * of which are treated as POSIX symlinks. Further, we only care when
-  * invoked via lstat, which seeks information about the link instead of its
-  * target. Otherwise, reparse points must be treated as regular files.
-  */
-  if (do_lstat &&
-      (file_info.BasicInformation.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
-    /*
-     * If reading the link fails, the reparse point is not a symlink and needs
-     * to be treated as a regular file. The higher level lstat function will
-     * detect this failure and retry without do_lstat if appropriate.
-     */
-    if (fs__readlink_handle(handle, NULL, &statbuf->st_size) != 0)
-      return -1;
-    statbuf->st_mode |= S_IFLNK;
-  }
-
-  if (statbuf->st_mode == 0) {
-    if (file_info.BasicInformation.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-      statbuf->st_mode |= _S_IFDIR;
-      statbuf->st_size = 0;
-    } else {
-      statbuf->st_mode |= _S_IFREG;
-      statbuf->st_size = file_info.StandardInformation.EndOfFile.QuadPart;
-    }
-  }
-
-  if (file_info.BasicInformation.FileAttributes & FILE_ATTRIBUTE_READONLY)
-    statbuf->st_mode |= _S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6);
-  else
-    statbuf->st_mode |= (_S_IREAD | _S_IWRITE) | ((_S_IREAD | _S_IWRITE) >> 3) |
-                        ((_S_IREAD | _S_IWRITE) >> 6);
-
-  FILETIME_TO_TIMESPEC(statbuf->st_atim, file_info.BasicInformation.LastAccessTime);
-  FILETIME_TO_TIMESPEC(statbuf->st_ctim, file_info.BasicInformation.ChangeTime);
-  FILETIME_TO_TIMESPEC(statbuf->st_mtim, file_info.BasicInformation.LastWriteTime);
-  FILETIME_TO_TIMESPEC(statbuf->st_birthtim, file_info.BasicInformation.CreationTime);
-
-  statbuf->st_ino = file_info.InternalInformation.IndexNumber.QuadPart;
-
-  /* st_blocks contains the on-disk allocation size in 512-byte units. */
-  statbuf->st_blocks =
-      (uint64_t) file_info.StandardInformation.AllocationSize.QuadPart >> 9;
-
-  statbuf->st_nlink = file_info.StandardInformation.NumberOfLinks;
-
-  /* The st_blksize is supposed to be the 'optimal' number of bytes for reading
-   * and writing to the disk. That is, for any definition of 'optimal' - it's
-   * supposed to at least avoid read-update-write behavior when writing to the
-   * disk.
-   *
-   * However nobody knows this and even fewer people actually use this value,
-   * and in order to fill it out we'd have to make another syscall to query the
-   * volume for FILE_FS_SECTOR_SIZE_INFORMATION.
-   *
-   * Therefore we'll just report a sensible value that's quite commonly okay
-   * on modern hardware.
-   *
-   * 4096 is the minimum required to be compatible with newer Advanced Format
-   * drives (which have 4096 bytes per physical sector), and to be backwards
-   * compatible with older drives (which have 512 bytes per physical sector).
-   */
-  statbuf->st_blksize = 4096;
-
-  /* Todo: set st_flags to something meaningful. Also provide a wrapper for
-   * chattr(2).
-   */
-  statbuf->st_flags = 0;
-
-  /* Windows has nothing sensible to say about these values, so they'll just
-   * remain empty.
-   */
-  statbuf->st_gid = 0;
-  statbuf->st_uid = 0;
-  statbuf->st_rdev = 0;
-  statbuf->st_gen = 0;
-
-  return 0;
-}
-
-
-INLINE static void fs__stat_prepare_path(WCHAR* pathw) {
-  size_t len = wcslen(pathw);
-
-  /* TODO: ignore namespaced paths. */
-  if (len > 1 && pathw[len - 2] != L':' &&
-      (pathw[len - 1] == L'\\' || pathw[len - 1] == L'/')) {
-    pathw[len - 1] = '\0';
-  }
-}
-
-
-INLINE static DWORD fs__stat_impl_from_path(WCHAR* path,
-                                            int do_lstat,
-                                            uv_stat_t* statbuf) {
-  HANDLE handle;
-  DWORD flags;
-  DWORD ret;
-
-  flags = FILE_FLAG_BACKUP_SEMANTICS;
-  if (do_lstat)
-    flags |= FILE_FLAG_OPEN_REPARSE_POINT;
-
-  handle = CreateFileW(path,
-                       FILE_READ_ATTRIBUTES,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                       NULL,
-                       OPEN_EXISTING,
-                       flags,
-                       NULL);
-
-  if (handle == INVALID_HANDLE_VALUE)
-    ret = GetLastError();
-  else if (fs__stat_handle(handle, statbuf, do_lstat) != 0)
-    ret = GetLastError();
-  else
-    ret = 0;
-
-  CloseHandle(handle);
-  return ret;
-}
-
-
-INLINE static void fs__stat_impl(uv_fs_t* req, int do_lstat) {
-  DWORD error;
-
-  error = fs__stat_impl_from_path(req->file.pathw, do_lstat, &req->statbuf);
-  if (error != 0) {
-    if (do_lstat &&
-        (error == ERROR_SYMLINK_NOT_SUPPORTED ||
-         error == ERROR_NOT_A_REPARSE_POINT)) {
-      /* We opened a reparse point but it was not a symlink. Try again. */
-      fs__stat_impl(req, 0);
-    } else {
-      /* Stat failed. */
-      SET_REQ_WIN32_ERROR(req, error);
-    }
-
-    return;
-  }
-
-  req->ptr = &req->statbuf;
-  req->result = 0;
-}
-
-
-static void fs__stat(uv_fs_t* req) {
-  fs__stat_prepare_path(req->file.pathw);
-  fs__stat_impl(req, 0);
-}
-
-
-static void fs__lstat(uv_fs_t* req) {
-  fs__stat_prepare_path(req->file.pathw);
-  fs__stat_impl(req, 1);
-}
-
-
-static void fs__fstat(uv_fs_t* req) {
-  int fd = req->file.fd;
-  HANDLE handle;
-
-  VERIFY_FD(fd, req);
-
-  handle = uv__get_osfhandle(fd);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
-    return;
-  }
-
-  if (fs__stat_handle(handle, &req->statbuf, 0) != 0) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  req->ptr = &req->statbuf;
-  req->result = 0;
-}
-
-
-static void fs__rename(uv_fs_t* req) {
-  if (!MoveFileExW(req->file.pathw, req->fs.info.new_pathw, MOVEFILE_REPLACE_EXISTING)) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  SET_REQ_RESULT(req, 0);
-}
-
-
-INLINE static void fs__sync_impl(uv_fs_t* req) {
-  int fd = req->file.fd;
-  int result;
-
-  VERIFY_FD(fd, req);
-
-  result = FlushFileBuffers(uv__get_osfhandle(fd)) ? 0 : -1;
-  if (result == -1) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-  } else {
-    SET_REQ_RESULT(req, result);
-  }
-}
-
-
-static void fs__fsync(uv_fs_t* req) {
-  fs__sync_impl(req);
-}
-
-
-static void fs__fdatasync(uv_fs_t* req) {
-  fs__sync_impl(req);
-}
-
-
-static void fs__ftruncate(uv_fs_t* req) {
-  int fd = req->file.fd;
-  HANDLE handle;
-  NTSTATUS status;
-  IO_STATUS_BLOCK io_status;
-  FILE_END_OF_FILE_INFORMATION eof_info;
-
-  VERIFY_FD(fd, req);
-
-  handle = uv__get_osfhandle(fd);
-
-  eof_info.EndOfFile.QuadPart = req->fs.info.offset;
-
-  status = pNtSetInformationFile(handle,
-                                 &io_status,
-                                 &eof_info,
-                                 sizeof eof_info,
-                                 FileEndOfFileInformation);
-
-  if (NT_SUCCESS(status)) {
-    SET_REQ_RESULT(req, 0);
-  } else {
-    SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
-  }
-}
-
-
-static void fs__copyfile(uv_fs_t* req) {
-  int flags;
-  int overwrite;
-  uv_stat_t statbuf;
-  uv_stat_t new_statbuf;
-
-  flags = req->fs.info.file_flags;
-
-  if (flags & UV_FS_COPYFILE_FICLONE_FORCE) {
-    SET_REQ_UV_ERROR(req, UV_ENOSYS, ERROR_NOT_SUPPORTED);
-    return;
-  }
-
-  overwrite = flags & UV_FS_COPYFILE_EXCL;
-
-  if (CopyFileW(req->file.pathw, req->fs.info.new_pathw, overwrite) != 0) {
-    SET_REQ_RESULT(req, 0);
-    return;
-  }
-
-  SET_REQ_WIN32_ERROR(req, GetLastError());
-  if (req->result != UV_EBUSY)
-    return;
-
-  /* if error UV_EBUSY check if src and dst file are the same */
-  if (fs__stat_impl_from_path(req->file.pathw, 0, &statbuf) != 0 ||
-      fs__stat_impl_from_path(req->fs.info.new_pathw, 0, &new_statbuf) != 0) {
-    return;
-  }
-
-  if (statbuf.st_dev == new_statbuf.st_dev &&
-      statbuf.st_ino == new_statbuf.st_ino) {
-    SET_REQ_RESULT(req, 0);
-  }
-}
-
-
-static void fs__sendfile(uv_fs_t* req) {
-  int fd_in = req->file.fd, fd_out = req->fs.info.fd_out;
-  size_t length = req->fs.info.bufsml[0].len;
-  int64_t offset = req->fs.info.offset;
-  const size_t max_buf_size = 65536;
-  size_t buf_size = length < max_buf_size ? length : max_buf_size;
-  int n, result = 0;
-  int64_t result_offset = 0;
-  char* buf = (char*) uv__malloc(buf_size);
-  if (!buf) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  if (offset != -1) {
-    result_offset = _lseeki64(fd_in, offset, SEEK_SET);
-  }
-
-  if (result_offset == -1) {
-    result = -1;
-  } else {
-    while (length > 0) {
-      n = _read(fd_in, buf, length < buf_size ? length : buf_size);
-      if (n == 0) {
-        break;
-      } else if (n == -1) {
-        result = -1;
-        break;
-      }
-
-      length -= n;
-
-      n = _write(fd_out, buf, n);
-      if (n == -1) {
-        result = -1;
-        break;
-      }
-
-      result += n;
-    }
-  }
-
-  uv__free(buf);
-
-  SET_REQ_RESULT(req, result);
-}
-
-
-static void fs__access(uv_fs_t* req) {
-  DWORD attr = GetFileAttributesW(req->file.pathw);
-
-  if (attr == INVALID_FILE_ATTRIBUTES) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  /*
-   * Access is possible if
-   * - write access wasn't requested,
-   * - or the file isn't read-only,
-   * - or it's a directory.
-   * (Directories cannot be read-only on Windows.)
-   */
-  if (!(req->fs.info.mode & W_OK) ||
-      !(attr & FILE_ATTRIBUTE_READONLY) ||
-      (attr & FILE_ATTRIBUTE_DIRECTORY)) {
-    SET_REQ_RESULT(req, 0);
-  } else {
-    SET_REQ_WIN32_ERROR(req, UV_EPERM);
-  }
-
-}
-
-
-static void fs__chmod(uv_fs_t* req) {
-  int result = _wchmod(req->file.pathw, req->fs.info.mode);
-  SET_REQ_RESULT(req, result);
-}
-
-
-static void fs__fchmod(uv_fs_t* req) {
-  int fd = req->file.fd;
-  int clear_archive_flag;
-  HANDLE handle;
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-  FILE_BASIC_INFORMATION file_info;
-
-  VERIFY_FD(fd, req);
-
-  handle = ReOpenFile(uv__get_osfhandle(fd), FILE_WRITE_ATTRIBUTES, 0, 0);
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  nt_status = pNtQueryInformationFile(handle,
-                                      &io_status,
-                                      &file_info,
-                                      sizeof file_info,
-                                      FileBasicInformation);
-
-  if (!NT_SUCCESS(nt_status)) {
-    SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
-    goto fchmod_cleanup;
-  }
-
-  /* Test if the Archive attribute is cleared */
-  if ((file_info.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == 0) {
-      /* Set Archive flag, otherwise setting or clearing the read-only
-         flag will not work */
-      file_info.FileAttributes |= FILE_ATTRIBUTE_ARCHIVE;
-      nt_status = pNtSetInformationFile(handle,
-                                        &io_status,
-                                        &file_info,
-                                        sizeof file_info,
-                                        FileBasicInformation);
-      if (!NT_SUCCESS(nt_status)) {
-        SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
-        goto fchmod_cleanup;
-      }
-      /* Remeber to clear the flag later on */
-      clear_archive_flag = 1;
-  } else {
-      clear_archive_flag = 0;
-  }
-
-  if (req->fs.info.mode & _S_IWRITE) {
-    file_info.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
-  } else {
-    file_info.FileAttributes |= FILE_ATTRIBUTE_READONLY;
-  }
-
-  nt_status = pNtSetInformationFile(handle,
-                                    &io_status,
-                                    &file_info,
-                                    sizeof file_info,
-                                    FileBasicInformation);
-
-  if (!NT_SUCCESS(nt_status)) {
-    SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
-    goto fchmod_cleanup;
-  }
-
-  if (clear_archive_flag) {
-      file_info.FileAttributes &= ~FILE_ATTRIBUTE_ARCHIVE;
-      if (file_info.FileAttributes == 0) {
-          file_info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
-      }
-      nt_status = pNtSetInformationFile(handle,
-                                        &io_status,
-                                        &file_info,
-                                        sizeof file_info,
-                                        FileBasicInformation);
-      if (!NT_SUCCESS(nt_status)) {
-        SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
-        goto fchmod_cleanup;
-      }
-  }
-
-  SET_REQ_SUCCESS(req);
-fchmod_cleanup:
-  CloseHandle(handle);
-}
-
-
-INLINE static int fs__utime_handle(HANDLE handle, double atime, double mtime) {
-  FILETIME filetime_a, filetime_m;
-
-  TIME_T_TO_FILETIME(atime, &filetime_a);
-  TIME_T_TO_FILETIME(mtime, &filetime_m);
-
-  if (!SetFileTime(handle, NULL, &filetime_a, &filetime_m)) {
-    return -1;
-  }
-
-  return 0;
-}
-
-
-static void fs__utime(uv_fs_t* req) {
-  HANDLE handle;
-
-  handle = CreateFileW(req->file.pathw,
-                       FILE_WRITE_ATTRIBUTES,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                       NULL,
-                       OPEN_EXISTING,
-                       FILE_FLAG_BACKUP_SEMANTICS,
-                       NULL);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    CloseHandle(handle);
-    return;
-  }
-
-  CloseHandle(handle);
-
-  req->result = 0;
-}
-
-
-static void fs__futime(uv_fs_t* req) {
-  int fd = req->file.fd;
-  HANDLE handle;
-  VERIFY_FD(fd, req);
-
-  handle = uv__get_osfhandle(fd);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
-    return;
-  }
-
-  if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  req->result = 0;
-}
-
-
-static void fs__link(uv_fs_t* req) {
-  DWORD r = CreateHardLinkW(req->fs.info.new_pathw, req->file.pathw, NULL);
-  if (r == 0) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-  } else {
-    req->result = 0;
-  }
-}
-
-
-static void fs__create_junction(uv_fs_t* req, const WCHAR* path,
-    const WCHAR* new_path) {
-  HANDLE handle = INVALID_HANDLE_VALUE;
-  REPARSE_DATA_BUFFER *buffer = NULL;
-  int created = 0;
-  int target_len;
-  int is_absolute, is_long_path;
-  int needed_buf_size, used_buf_size, used_data_size, path_buf_len;
-  int start, len, i;
-  int add_slash;
-  DWORD bytes;
-  WCHAR* path_buf;
-
-  target_len = wcslen(path);
-  is_long_path = wcsncmp(path, LONG_PATH_PREFIX, LONG_PATH_PREFIX_LEN) == 0;
-
-  if (is_long_path) {
-    is_absolute = 1;
-  } else {
-    is_absolute = target_len >= 3 && IS_LETTER(path[0]) &&
-      path[1] == L':' && IS_SLASH(path[2]);
-  }
-
-  if (!is_absolute) {
-    /* Not supporting relative paths */
-    SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_NOT_SUPPORTED);
-    return;
-  }
-
-  /* Do a pessimistic calculation of the required buffer size */
-  needed_buf_size =
-      FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer) +
-      JUNCTION_PREFIX_LEN * sizeof(WCHAR) +
-      2 * (target_len + 2) * sizeof(WCHAR);
-
-  /* Allocate the buffer */
-  buffer = (REPARSE_DATA_BUFFER*)uv__malloc(needed_buf_size);
-  if (!buffer) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  /* Grab a pointer to the part of the buffer where filenames go */
-  path_buf = (WCHAR*)&(buffer->MountPointReparseBuffer.PathBuffer);
-  path_buf_len = 0;
-
-  /* Copy the substitute (internal) target path */
-  start = path_buf_len;
-
-  wcsncpy((WCHAR*)&path_buf[path_buf_len], JUNCTION_PREFIX,
-    JUNCTION_PREFIX_LEN);
-  path_buf_len += JUNCTION_PREFIX_LEN;
-
-  add_slash = 0;
-  for (i = is_long_path ? LONG_PATH_PREFIX_LEN : 0; path[i] != L'\0'; i++) {
-    if (IS_SLASH(path[i])) {
-      add_slash = 1;
-      continue;
-    }
-
-    if (add_slash) {
-      path_buf[path_buf_len++] = L'\\';
-      add_slash = 0;
-    }
-
-    path_buf[path_buf_len++] = path[i];
-  }
-  path_buf[path_buf_len++] = L'\\';
-  len = path_buf_len - start;
-
-  /* Set the info about the substitute name */
-  buffer->MountPointReparseBuffer.SubstituteNameOffset = start * sizeof(WCHAR);
-  buffer->MountPointReparseBuffer.SubstituteNameLength = len * sizeof(WCHAR);
-
-  /* Insert null terminator */
-  path_buf[path_buf_len++] = L'\0';
-
-  /* Copy the print name of the target path */
-  start = path_buf_len;
-  add_slash = 0;
-  for (i = is_long_path ? LONG_PATH_PREFIX_LEN : 0; path[i] != L'\0'; i++) {
-    if (IS_SLASH(path[i])) {
-      add_slash = 1;
-      continue;
-    }
-
-    if (add_slash) {
-      path_buf[path_buf_len++] = L'\\';
-      add_slash = 0;
-    }
-
-    path_buf[path_buf_len++] = path[i];
-  }
-  len = path_buf_len - start;
-  if (len == 2) {
-    path_buf[path_buf_len++] = L'\\';
-    len++;
-  }
-
-  /* Set the info about the print name */
-  buffer->MountPointReparseBuffer.PrintNameOffset = start * sizeof(WCHAR);
-  buffer->MountPointReparseBuffer.PrintNameLength = len * sizeof(WCHAR);
-
-  /* Insert another null terminator */
-  path_buf[path_buf_len++] = L'\0';
-
-  /* Calculate how much buffer space was actually used */
-  used_buf_size = FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer) +
-    path_buf_len * sizeof(WCHAR);
-  used_data_size = used_buf_size -
-    FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer);
-
-  /* Put general info in the data buffer */
-  buffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
-  buffer->ReparseDataLength = used_data_size;
-  buffer->Reserved = 0;
-
-  /* Create a new directory */
-  if (!CreateDirectoryW(new_path, NULL)) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    goto error;
-  }
-  created = 1;
-
-  /* Open the directory */
-  handle = CreateFileW(new_path,
-                       GENERIC_WRITE,
-                       0,
-                       NULL,
-                       OPEN_EXISTING,
-                       FILE_FLAG_BACKUP_SEMANTICS |
-                         FILE_FLAG_OPEN_REPARSE_POINT,
-                       NULL);
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    goto error;
-  }
-
-  /* Create the actual reparse point */
-  if (!DeviceIoControl(handle,
-                       FSCTL_SET_REPARSE_POINT,
-                       buffer,
-                       used_buf_size,
-                       NULL,
-                       0,
-                       &bytes,
-                       NULL)) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    goto error;
-  }
-
-  /* Clean up */
-  CloseHandle(handle);
-  uv__free(buffer);
-
-  SET_REQ_RESULT(req, 0);
-  return;
-
-error:
-  uv__free(buffer);
-
-  if (handle != INVALID_HANDLE_VALUE) {
-    CloseHandle(handle);
-  }
-
-  if (created) {
-    RemoveDirectoryW(new_path);
-  }
-}
-
-
-static void fs__symlink(uv_fs_t* req) {
-  WCHAR* pathw;
-  WCHAR* new_pathw;
-  int flags;
-  int err;
-
-  pathw = req->file.pathw;
-  new_pathw = req->fs.info.new_pathw;
-
-  if (req->fs.info.file_flags & UV_FS_SYMLINK_JUNCTION) {
-    fs__create_junction(req, pathw, new_pathw);
-    return;
-  }
-
-  if (req->fs.info.file_flags & UV_FS_SYMLINK_DIR)
-    flags = SYMBOLIC_LINK_FLAG_DIRECTORY | uv__file_symlink_usermode_flag;
-  else
-    flags = uv__file_symlink_usermode_flag;
-
-  if (CreateSymbolicLinkW(new_pathw, pathw, flags)) {
-    SET_REQ_RESULT(req, 0);
-    return;
-  }
-
-  /* Something went wrong. We will test if it is because of user-mode
-   * symlinks.
-   */
-  err = GetLastError();
-  if (err == ERROR_INVALID_PARAMETER &&
-      flags & SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE) {
-    /* This system does not support user-mode symlinks. We will clear the
-     * unsupported flag and retry.
-     */
-    uv__file_symlink_usermode_flag = 0;
-    fs__symlink(req);
-  } else {
-    SET_REQ_WIN32_ERROR(req, err);
-  }
-}
-
-
-static void fs__readlink(uv_fs_t* req) {
-  HANDLE handle;
-
-  handle = CreateFileW(req->file.pathw,
-                       0,
-                       0,
-                       NULL,
-                       OPEN_EXISTING,
-                       FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
-                       NULL);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    CloseHandle(handle);
-    return;
-  }
-
-  req->flags |= UV_FS_FREE_PTR;
-  SET_REQ_RESULT(req, 0);
-
-  CloseHandle(handle);
-}
-
-
-static ssize_t fs__realpath_handle(HANDLE handle, char** realpath_ptr) {
-  int r;
-  DWORD w_realpath_len;
-  WCHAR* w_realpath_ptr = NULL;
-  WCHAR* w_realpath_buf;
-
-  w_realpath_len = GetFinalPathNameByHandleW(handle, NULL, 0, VOLUME_NAME_DOS);
-  if (w_realpath_len == 0) {
-    return -1;
-  }
-
-  w_realpath_buf = (WCHAR*)uv__malloc((w_realpath_len + 1) * sizeof(WCHAR));
-  if (w_realpath_buf == NULL) {
-    SetLastError(ERROR_OUTOFMEMORY);
-    return -1;
-  }
-  w_realpath_ptr = w_realpath_buf;
-
-  if (GetFinalPathNameByHandleW(
-          handle, w_realpath_ptr, w_realpath_len, VOLUME_NAME_DOS) == 0) {
-    uv__free(w_realpath_buf);
-    SetLastError(ERROR_INVALID_HANDLE);
-    return -1;
-  }
-
-  /* convert UNC path to long path */
-  if (wcsncmp(w_realpath_ptr,
-              UNC_PATH_PREFIX,
-              UNC_PATH_PREFIX_LEN) == 0) {
-    w_realpath_ptr += 6;
-    *w_realpath_ptr = L'\\';
-    w_realpath_len -= 6;
-  } else if (wcsncmp(w_realpath_ptr,
-                      LONG_PATH_PREFIX,
-                      LONG_PATH_PREFIX_LEN) == 0) {
-    w_realpath_ptr += 4;
-    w_realpath_len -= 4;
-  } else {
-    uv__free(w_realpath_buf);
-    SetLastError(ERROR_INVALID_HANDLE);
-    return -1;
-  }
-
-  r = fs__wide_to_utf8(w_realpath_ptr, w_realpath_len, realpath_ptr, NULL);
-  uv__free(w_realpath_buf);
-  return r;
-}
-
-static void fs__realpath(uv_fs_t* req) {
-  HANDLE handle;
-
-  handle = CreateFileW(req->file.pathw,
-                       0,
-                       0,
-                       NULL,
-                       OPEN_EXISTING,
-                       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS,
-                       NULL);
-  if (handle == INVALID_HANDLE_VALUE) {
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) {
-    CloseHandle(handle);
-    SET_REQ_WIN32_ERROR(req, GetLastError());
-    return;
-  }
-
-  CloseHandle(handle);
-  req->flags |= UV_FS_FREE_PTR;
-  SET_REQ_RESULT(req, 0);
-}
-
-
-static void fs__chown(uv_fs_t* req) {
-  req->result = 0;
-}
-
-
-static void fs__fchown(uv_fs_t* req) {
-  req->result = 0;
-}
-
-
-static void fs__lchown(uv_fs_t* req) {
-  req->result = 0;
-}
-
-static void uv__fs_work(struct uv__work* w) {
-  uv_fs_t* req;
-
-  req = container_of(w, uv_fs_t, work_req);
-  assert(req->type == UV_FS);
-
-#define XX(uc, lc)  case UV_FS_##uc: fs__##lc(req); break;
-  switch (req->fs_type) {
-    XX(OPEN, open)
-    XX(CLOSE, close)
-    XX(READ, read)
-    XX(WRITE, write)
-    XX(COPYFILE, copyfile)
-    XX(SENDFILE, sendfile)
-    XX(STAT, stat)
-    XX(LSTAT, lstat)
-    XX(FSTAT, fstat)
-    XX(FTRUNCATE, ftruncate)
-    XX(UTIME, utime)
-    XX(FUTIME, futime)
-    XX(ACCESS, access)
-    XX(CHMOD, chmod)
-    XX(FCHMOD, fchmod)
-    XX(FSYNC, fsync)
-    XX(FDATASYNC, fdatasync)
-    XX(UNLINK, unlink)
-    XX(RMDIR, rmdir)
-    XX(MKDIR, mkdir)
-    XX(MKDTEMP, mkdtemp)
-    XX(RENAME, rename)
-    XX(SCANDIR, scandir)
-    XX(READDIR, readdir)
-    XX(OPENDIR, opendir)
-    XX(CLOSEDIR, closedir)
-    XX(LINK, link)
-    XX(SYMLINK, symlink)
-    XX(READLINK, readlink)
-    XX(REALPATH, realpath)
-    XX(CHOWN, chown)
-    XX(FCHOWN, fchown);
-    XX(LCHOWN, lchown);
-    default:
-      assert(!"bad uv_fs_type");
-  }
-}
-
-
-static void uv__fs_done(struct uv__work* w, int status) {
-  uv_fs_t* req;
-
-  req = container_of(w, uv_fs_t, work_req);
-  uv__req_unregister(req->loop, req);
-
-  if (status == UV_ECANCELED) {
-    assert(req->result == 0);
-    req->result = UV_ECANCELED;
-  }
-
-  req->cb(req);
-}
-
-
-void uv_fs_req_cleanup(uv_fs_t* req) {
-  if (req == NULL)
-    return;
-
-  if (req->flags & UV_FS_CLEANEDUP)
-    return;
-
-  if (req->flags & UV_FS_FREE_PATHS)
-    uv__free(req->file.pathw);
-
-  if (req->flags & UV_FS_FREE_PTR) {
-    if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
-      uv__fs_scandir_cleanup(req);
-    else if (req->fs_type == UV_FS_READDIR)
-      uv__fs_readdir_cleanup(req);
-    else
-      uv__free(req->ptr);
-  }
-
-  if (req->fs.info.bufs != req->fs.info.bufsml)
-    uv__free(req->fs.info.bufs);
-
-  req->path = NULL;
-  req->file.pathw = NULL;
-  req->fs.info.new_pathw = NULL;
-  req->fs.info.bufs = NULL;
-  req->ptr = NULL;
-
-  req->flags |= UV_FS_CLEANEDUP;
-}
-
-
-int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
-    int mode, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_OPEN);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.info.file_flags = flags;
-  req->fs.info.mode = mode;
-  POST;
-}
-
-
-int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
-  INIT(UV_FS_CLOSE);
-  req->file.fd = fd;
-  POST;
-}
-
-
-int uv_fs_read(uv_loop_t* loop,
-               uv_fs_t* req,
-               uv_file fd,
-               const uv_buf_t bufs[],
-               unsigned int nbufs,
-               int64_t offset,
-               uv_fs_cb cb) {
-  INIT(UV_FS_READ);
-
-  if (bufs == NULL || nbufs == 0)
-    return UV_EINVAL;
-
-  req->file.fd = fd;
-
-  req->fs.info.nbufs = nbufs;
-  req->fs.info.bufs = req->fs.info.bufsml;
-  if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
-    req->fs.info.bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs));
-
-  if (req->fs.info.bufs == NULL)
-    return UV_ENOMEM;
-
-  memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
-
-  req->fs.info.offset = offset;
-  POST;
-}
-
-
-int uv_fs_write(uv_loop_t* loop,
-                uv_fs_t* req,
-                uv_file fd,
-                const uv_buf_t bufs[],
-                unsigned int nbufs,
-                int64_t offset,
-                uv_fs_cb cb) {
-  INIT(UV_FS_WRITE);
-
-  if (bufs == NULL || nbufs == 0)
-    return UV_EINVAL;
-
-  req->file.fd = fd;
-
-  req->fs.info.nbufs = nbufs;
-  req->fs.info.bufs = req->fs.info.bufsml;
-  if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
-    req->fs.info.bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs));
-
-  if (req->fs.info.bufs == NULL)
-    return UV_ENOMEM;
-
-  memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
-
-  req->fs.info.offset = offset;
-  POST;
-}
-
-
-int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_UNLINK);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_MKDIR);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.info.mode = mode;
-  POST;
-}
-
-
-int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_MKDTEMP);
-  err = fs__capture_path(req, tpl, NULL, TRUE);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  POST;
-}
-
-
-int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_RMDIR);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_SCANDIR);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.info.file_flags = flags;
-  POST;
-}
-
-int uv_fs_opendir(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  const char* path,
-                  uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_OPENDIR);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err)
-    return uv_translate_sys_error(err);
-  POST;
-}
-
-int uv_fs_readdir(uv_loop_t* loop,
-                  uv_fs_t* req,
-                  uv_dir_t* dir,
-                  uv_fs_cb cb) {
-  INIT(UV_FS_READDIR);
-
-  if (dir == NULL ||
-      dir->dirents == NULL ||
-      dir->dir_handle == INVALID_HANDLE_VALUE) {
-    return UV_EINVAL;
-  }
-
-  req->ptr = dir;
-  POST;
-}
-
-int uv_fs_closedir(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   uv_dir_t* dir,
-                   uv_fs_cb cb) {
-  INIT(UV_FS_CLOSEDIR);
-  if (dir == NULL)
-    return UV_EINVAL;
-  req->ptr = dir;
-  POST;
-}
-
-int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    const char* new_path, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_LINK);
-  err = fs__capture_path(req, path, new_path, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    const char* new_path, int flags, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_SYMLINK);
-  err = fs__capture_path(req, path, new_path, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.info.file_flags = flags;
-  POST;
-}
-
-
-int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_READLINK);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_REALPATH);
-
-  if (!path) {
-    return UV_EINVAL;
-  }
-
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
-    uv_gid_t gid, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_CHOWN);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_uid_t uid,
-    uv_gid_t gid, uv_fs_cb cb) {
-  INIT(UV_FS_FCHOWN);
-  POST;
-}
-
-
-int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
-    uv_gid_t gid, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_LCHOWN);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-  POST;
-}
-
-
-int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_STAT);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_LSTAT);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
-  INIT(UV_FS_FSTAT);
-  req->file.fd = fd;
-  POST;
-}
-
-
-int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    const char* new_path, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_RENAME);
-  err = fs__capture_path(req, path, new_path, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  POST;
-}
-
-
-int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
-  INIT(UV_FS_FSYNC);
-  req->file.fd = fd;
-  POST;
-}
-
-
-int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
-  INIT(UV_FS_FDATASYNC);
-  req->file.fd = fd;
-  POST;
-}
-
-
-int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file fd,
-    int64_t offset, uv_fs_cb cb) {
-  INIT(UV_FS_FTRUNCATE);
-  req->file.fd = fd;
-  req->fs.info.offset = offset;
-  POST;
-}
-
-
-int uv_fs_copyfile(uv_loop_t* loop,
-                   uv_fs_t* req,
-                   const char* path,
-                   const char* new_path,
-                   int flags,
-                   uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_COPYFILE);
-
-  if (flags & ~(UV_FS_COPYFILE_EXCL |
-                UV_FS_COPYFILE_FICLONE |
-                UV_FS_COPYFILE_FICLONE_FORCE)) {
-    return UV_EINVAL;
-  }
-
-  err = fs__capture_path(req, path, new_path, cb != NULL);
-
-  if (err)
-    return uv_translate_sys_error(err);
-
-  req->fs.info.file_flags = flags;
-  POST;
-}
-
-
-int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file fd_out,
-    uv_file fd_in, int64_t in_offset, size_t length, uv_fs_cb cb) {
-  INIT(UV_FS_SENDFILE);
-  req->file.fd = fd_in;
-  req->fs.info.fd_out = fd_out;
-  req->fs.info.offset = in_offset;
-  req->fs.info.bufsml[0].len = length;
-  POST;
-}
-
-
-int uv_fs_access(uv_loop_t* loop,
-                 uv_fs_t* req,
-                 const char* path,
-                 int flags,
-                 uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_ACCESS);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  req->fs.info.mode = flags;
-  POST;
-}
-
-
-int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
-    uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_CHMOD);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.info.mode = mode;
-  POST;
-}
-
-
-int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file fd, int mode,
-    uv_fs_cb cb) {
-  INIT(UV_FS_FCHMOD);
-  req->file.fd = fd;
-  req->fs.info.mode = mode;
-  POST;
-}
-
-
-int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
-    double mtime, uv_fs_cb cb) {
-  int err;
-
-  INIT(UV_FS_UTIME);
-  err = fs__capture_path(req, path, NULL, cb != NULL);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  req->fs.time.atime = atime;
-  req->fs.time.mtime = mtime;
-  POST;
-}
-
-
-int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file fd, double atime,
-    double mtime, uv_fs_cb cb) {
-  INIT(UV_FS_FUTIME);
-  req->file.fd = fd;
-  req->fs.time.atime = atime;
-  req->fs.time.mtime = mtime;
-  POST;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/getaddrinfo.cpp b/wpiutil/src/main/native/libuv/src/win/getaddrinfo.cpp
deleted file mode 100644
index dfab860..0000000
--- a/wpiutil/src/main/native/libuv/src/win/getaddrinfo.cpp
+++ /dev/null
@@ -1,463 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "req-inl.h"
-#include "idna.h"
-
-/* EAI_* constants. */
-#include <winsock2.h>
-
-/* Needed for ConvertInterfaceIndexToLuid and ConvertInterfaceLuidToNameA */
-#include <iphlpapi.h>
-
-int uv__getaddrinfo_translate_error(int sys_err) {
-  switch (sys_err) {
-    case 0:                       return 0;
-    case WSATRY_AGAIN:            return UV_EAI_AGAIN;
-    case WSAEINVAL:               return UV_EAI_BADFLAGS;
-    case WSANO_RECOVERY:          return UV_EAI_FAIL;
-    case WSAEAFNOSUPPORT:         return UV_EAI_FAMILY;
-    case WSA_NOT_ENOUGH_MEMORY:   return UV_EAI_MEMORY;
-    case WSAHOST_NOT_FOUND:       return UV_EAI_NONAME;
-    case WSATYPE_NOT_FOUND:       return UV_EAI_SERVICE;
-    case WSAESOCKTNOSUPPORT:      return UV_EAI_SOCKTYPE;
-    default:                      return uv_translate_sys_error(sys_err);
-  }
-}
-
-
-/*
- * MinGW is missing this
- */
-#if !defined(_MSC_VER) && !defined(__MINGW64_VERSION_MAJOR)
-  typedef struct addrinfoW {
-    int ai_flags;
-    int ai_family;
-    int ai_socktype;
-    int ai_protocol;
-    size_t ai_addrlen;
-    WCHAR* ai_canonname;
-    struct sockaddr* ai_addr;
-    struct addrinfoW* ai_next;
-  } ADDRINFOW, *PADDRINFOW;
-
-  DECLSPEC_IMPORT int WSAAPI GetAddrInfoW(const WCHAR* node,
-                                          const WCHAR* service,
-                                          const ADDRINFOW* hints,
-                                          PADDRINFOW* result);
-
-  DECLSPEC_IMPORT void WSAAPI FreeAddrInfoW(PADDRINFOW pAddrInfo);
-#endif
-
-
-/* Adjust size value to be multiple of 4. Use to keep pointer aligned.
- * Do we need different versions of this for different architectures? */
-#define ALIGNED_SIZE(X)     ((((X) + 3) >> 2) << 2)
-
-#ifndef NDIS_IF_MAX_STRING_SIZE
-#define NDIS_IF_MAX_STRING_SIZE IF_MAX_STRING_SIZE
-#endif
-
-static void uv__getaddrinfo_work(struct uv__work* w) {
-  uv_getaddrinfo_t* req;
-  struct addrinfoW* hints;
-  int err;
-
-  req = container_of(w, uv_getaddrinfo_t, work_req);
-  hints = req->addrinfow;
-  req->addrinfow = NULL;
-  err = GetAddrInfoW(req->node, req->service, hints, &req->addrinfow);
-  req->retcode = uv__getaddrinfo_translate_error(err);
-}
-
-
-/*
- * Called from uv_run when complete. Call user specified callback
- * then free returned addrinfo
- * Returned addrinfo strings are converted from UTF-16 to UTF-8.
- *
- * To minimize allocation we calculate total size required,
- * and copy all structs and referenced strings into the one block.
- * Each size calculation is adjusted to avoid unaligned pointers.
- */
-static void uv__getaddrinfo_done(struct uv__work* w, int status) {
-  uv_getaddrinfo_t* req;
-  int addrinfo_len = 0;
-  int name_len = 0;
-  size_t addrinfo_struct_len = ALIGNED_SIZE(sizeof(struct addrinfo));
-  struct addrinfoW* addrinfow_ptr;
-  struct addrinfo* addrinfo_ptr;
-  char* alloc_ptr = NULL;
-  char* cur_ptr = NULL;
-
-  req = container_of(w, uv_getaddrinfo_t, work_req);
-
-  /* release input parameter memory */
-  uv__free(req->alloc);
-  req->alloc = NULL;
-
-  if (status == UV_ECANCELED) {
-    assert(req->retcode == 0);
-    req->retcode = UV_EAI_CANCELED;
-    goto complete;
-  }
-
-  if (req->retcode == 0) {
-    /* Convert addrinfoW to addrinfo. First calculate required length. */
-    addrinfow_ptr = req->addrinfow;
-    while (addrinfow_ptr != NULL) {
-      addrinfo_len += addrinfo_struct_len +
-          ALIGNED_SIZE(addrinfow_ptr->ai_addrlen);
-      if (addrinfow_ptr->ai_canonname != NULL) {
-        name_len = WideCharToMultiByte(CP_UTF8,
-                                       0,
-                                       addrinfow_ptr->ai_canonname,
-                                       -1,
-                                       NULL,
-                                       0,
-                                       NULL,
-                                       NULL);
-        if (name_len == 0) {
-          req->retcode = uv_translate_sys_error(GetLastError());
-          goto complete;
-        }
-        addrinfo_len += ALIGNED_SIZE(name_len);
-      }
-      addrinfow_ptr = addrinfow_ptr->ai_next;
-    }
-
-    /* allocate memory for addrinfo results */
-    alloc_ptr = (char*)uv__malloc(addrinfo_len);
-
-    /* do conversions */
-    if (alloc_ptr != NULL) {
-      cur_ptr = alloc_ptr;
-      addrinfow_ptr = req->addrinfow;
-
-      while (addrinfow_ptr != NULL) {
-        /* copy addrinfo struct data */
-        assert(cur_ptr + addrinfo_struct_len <= alloc_ptr + addrinfo_len);
-        addrinfo_ptr = (struct addrinfo*)cur_ptr;
-        addrinfo_ptr->ai_family = addrinfow_ptr->ai_family;
-        addrinfo_ptr->ai_socktype = addrinfow_ptr->ai_socktype;
-        addrinfo_ptr->ai_protocol = addrinfow_ptr->ai_protocol;
-        addrinfo_ptr->ai_flags = addrinfow_ptr->ai_flags;
-        addrinfo_ptr->ai_addrlen = addrinfow_ptr->ai_addrlen;
-        addrinfo_ptr->ai_canonname = NULL;
-        addrinfo_ptr->ai_addr = NULL;
-        addrinfo_ptr->ai_next = NULL;
-
-        cur_ptr += addrinfo_struct_len;
-
-        /* copy sockaddr */
-        if (addrinfo_ptr->ai_addrlen > 0) {
-          assert(cur_ptr + addrinfo_ptr->ai_addrlen <=
-                 alloc_ptr + addrinfo_len);
-          memcpy(cur_ptr, addrinfow_ptr->ai_addr, addrinfo_ptr->ai_addrlen);
-          addrinfo_ptr->ai_addr = (struct sockaddr*)cur_ptr;
-          cur_ptr += ALIGNED_SIZE(addrinfo_ptr->ai_addrlen);
-        }
-
-        /* convert canonical name to UTF-8 */
-        if (addrinfow_ptr->ai_canonname != NULL) {
-          name_len = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         addrinfow_ptr->ai_canonname,
-                                         -1,
-                                         NULL,
-                                         0,
-                                         NULL,
-                                         NULL);
-          assert(name_len > 0);
-          assert(cur_ptr + name_len <= alloc_ptr + addrinfo_len);
-          name_len = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         addrinfow_ptr->ai_canonname,
-                                         -1,
-                                         cur_ptr,
-                                         name_len,
-                                         NULL,
-                                         NULL);
-          assert(name_len > 0);
-          addrinfo_ptr->ai_canonname = cur_ptr;
-          cur_ptr += ALIGNED_SIZE(name_len);
-        }
-        assert(cur_ptr <= alloc_ptr + addrinfo_len);
-
-        /* set next ptr */
-        addrinfow_ptr = addrinfow_ptr->ai_next;
-        if (addrinfow_ptr != NULL) {
-          addrinfo_ptr->ai_next = (struct addrinfo*)cur_ptr;
-        }
-      }
-      req->addrinfo = (struct addrinfo*)alloc_ptr;
-    } else {
-      req->retcode = UV_EAI_MEMORY;
-    }
-  }
-
-  /* return memory to system */
-  if (req->addrinfow != NULL) {
-    FreeAddrInfoW(req->addrinfow);
-    req->addrinfow = NULL;
-  }
-
-complete:
-  uv__req_unregister(req->loop, req);
-
-  /* finally do callback with converted result */
-  if (req->getaddrinfo_cb)
-    req->getaddrinfo_cb(req, req->retcode, req->addrinfo);
-}
-
-
-void uv_freeaddrinfo(struct addrinfo* ai) {
-  char* alloc_ptr = (char*)ai;
-
-  /* release copied result memory */
-  uv__free(alloc_ptr);
-}
-
-
-/*
- * Entry point for getaddrinfo
- * we convert the UTF-8 strings to UNICODE
- * and save the UNICODE string pointers in the req
- * We also copy hints so that caller does not need to keep memory until the
- * callback.
- * return 0 if a callback will be made
- * return error code if validation fails
- *
- * To minimize allocation we calculate total size required,
- * and copy all structs and referenced strings into the one block.
- * Each size calculation is adjusted to avoid unaligned pointers.
- */
-int uv_getaddrinfo(uv_loop_t* loop,
-                   uv_getaddrinfo_t* req,
-                   uv_getaddrinfo_cb getaddrinfo_cb,
-                   const char* node,
-                   const char* service,
-                   const struct addrinfo* hints) {
-  char hostname_ascii[256];
-  int nodesize = 0;
-  int servicesize = 0;
-  int hintssize = 0;
-  char* alloc_ptr = NULL;
-  int err;
-  long rc;
-
-  if (req == NULL || (node == NULL && service == NULL)) {
-    return UV_EINVAL;
-  }
-
-  UV_REQ_INIT(req, UV_GETADDRINFO);
-  req->getaddrinfo_cb = getaddrinfo_cb;
-  req->addrinfo = NULL;
-  req->loop = loop;
-  req->retcode = 0;
-
-  /* calculate required memory size for all input values */
-  if (node != NULL) {
-    rc = uv__idna_toascii(node,
-                          node + strlen(node),
-                          hostname_ascii,
-                          hostname_ascii + sizeof(hostname_ascii));
-    if (rc < 0)
-      return rc;
-    nodesize = ALIGNED_SIZE(MultiByteToWideChar(CP_UTF8, 0, hostname_ascii,
-                                                -1, NULL, 0) * sizeof(WCHAR));
-    if (nodesize == 0) {
-      err = GetLastError();
-      goto error;
-    }
-    node = hostname_ascii;
-  }
-
-  if (service != NULL) {
-    servicesize = ALIGNED_SIZE(MultiByteToWideChar(CP_UTF8,
-                                                   0,
-                                                   service,
-                                                   -1,
-                                                   NULL,
-                                                   0) *
-                               sizeof(WCHAR));
-    if (servicesize == 0) {
-      err = GetLastError();
-      goto error;
-    }
-  }
-  if (hints != NULL) {
-    hintssize = ALIGNED_SIZE(sizeof(struct addrinfoW));
-  }
-
-  /* allocate memory for inputs, and partition it as needed */
-  alloc_ptr = (char*)uv__malloc(nodesize + servicesize + hintssize);
-  if (!alloc_ptr) {
-    err = WSAENOBUFS;
-    goto error;
-  }
-
-  /* save alloc_ptr now so we can free if error */
-  req->alloc = (void*)alloc_ptr;
-
-  /* Convert node string to UTF16 into allocated memory and save pointer in the
-   * request. */
-  if (node != NULL) {
-    req->node = (WCHAR*)alloc_ptr;
-    if (MultiByteToWideChar(CP_UTF8,
-                            0,
-                            node,
-                            -1,
-                            (WCHAR*) alloc_ptr,
-                            nodesize / sizeof(WCHAR)) == 0) {
-      err = GetLastError();
-      goto error;
-    }
-    alloc_ptr += nodesize;
-  } else {
-    req->node = NULL;
-  }
-
-  /* Convert service string to UTF16 into allocated memory and save pointer in
-   * the req. */
-  if (service != NULL) {
-    req->service = (WCHAR*)alloc_ptr;
-    if (MultiByteToWideChar(CP_UTF8,
-                            0,
-                            service,
-                            -1,
-                            (WCHAR*) alloc_ptr,
-                            servicesize / sizeof(WCHAR)) == 0) {
-      err = GetLastError();
-      goto error;
-    }
-    alloc_ptr += servicesize;
-  } else {
-    req->service = NULL;
-  }
-
-  /* copy hints to allocated memory and save pointer in req */
-  if (hints != NULL) {
-    req->addrinfow = (struct addrinfoW*)alloc_ptr;
-    req->addrinfow->ai_family = hints->ai_family;
-    req->addrinfow->ai_socktype = hints->ai_socktype;
-    req->addrinfow->ai_protocol = hints->ai_protocol;
-    req->addrinfow->ai_flags = hints->ai_flags;
-    req->addrinfow->ai_addrlen = 0;
-    req->addrinfow->ai_canonname = NULL;
-    req->addrinfow->ai_addr = NULL;
-    req->addrinfow->ai_next = NULL;
-  } else {
-    req->addrinfow = NULL;
-  }
-
-  uv__req_register(loop, req);
-
-  if (getaddrinfo_cb) {
-    uv__work_submit(loop,
-                    &req->work_req,
-                    UV__WORK_SLOW_IO,
-                    uv__getaddrinfo_work,
-                    uv__getaddrinfo_done);
-    return 0;
-  } else {
-    uv__getaddrinfo_work(&req->work_req);
-    uv__getaddrinfo_done(&req->work_req, 0);
-    return req->retcode;
-  }
-
-error:
-  if (req != NULL) {
-    uv__free(req->alloc);
-    req->alloc = NULL;
-  }
-  return uv_translate_sys_error(err);
-}
-
-int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) {
-  NET_LUID luid;
-  wchar_t wname[NDIS_IF_MAX_STRING_SIZE + 1]; /* Add one for the NUL. */
-  DWORD bufsize;
-  int r;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  r = ConvertInterfaceIndexToLuid(ifindex, &luid);
-
-  if (r != 0)
-    return uv_translate_sys_error(r);
-
-  r = ConvertInterfaceLuidToNameW(&luid, wname, ARRAY_SIZE(wname));
-
-  if (r != 0)
-    return uv_translate_sys_error(r);
-
-  /* Check how much space we need */
-  bufsize = WideCharToMultiByte(CP_UTF8, 0, wname, -1, NULL, 0, NULL, NULL);
-
-  if (bufsize == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (bufsize > *size) {
-    *size = bufsize;
-    return UV_ENOBUFS;
-  }
-
-  /* Convert to UTF-8 */
-  bufsize = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                wname,
-                                -1,
-                                buffer,
-                                *size,
-                                NULL,
-                                NULL);
-
-  if (bufsize == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  *size = bufsize - 1;
-  return 0;
-}
-
-int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size) {
-  int r;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  r = snprintf(buffer, *size, "%d", ifindex);
-
-  if (r < 0)
-    return uv_translate_sys_error(r);
-
-  if (r >= (int) *size) {
-    *size = r + 1;
-    return UV_ENOBUFS;
-  }
-
-  *size = r;
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/getnameinfo.cpp b/wpiutil/src/main/native/libuv/src/win/getnameinfo.cpp
deleted file mode 100644
index b377338..0000000
--- a/wpiutil/src/main/native/libuv/src/win/getnameinfo.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
-*
-* 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 <assert.h>
-#include <stdio.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "req-inl.h"
-
-#ifndef GetNameInfo
-int WSAAPI GetNameInfoW(
-  const SOCKADDR *pSockaddr,
-  socklen_t SockaddrLength,
-  PWCHAR pNodeBuffer,
-  DWORD NodeBufferSize,
-  PWCHAR pServiceBuffer,
-  DWORD ServiceBufferSize,
-  INT Flags
-);
-#endif
-
-static void uv__getnameinfo_work(struct uv__work* w) {
-  uv_getnameinfo_t* req;
-  WCHAR host[NI_MAXHOST];
-  WCHAR service[NI_MAXSERV];
-  int ret;
-
-  req = container_of(w, uv_getnameinfo_t, work_req);
-  if (GetNameInfoW((struct sockaddr*)&req->storage,
-                   sizeof(req->storage),
-                   host,
-                   ARRAY_SIZE(host),
-                   service,
-                   ARRAY_SIZE(service),
-                   req->flags)) {
-    ret = WSAGetLastError();
-    req->retcode = uv__getaddrinfo_translate_error(ret);
-    return;
-  }
-
-  ret = WideCharToMultiByte(CP_UTF8,
-                            0,
-                            host,
-                            -1,
-                            req->host,
-                            sizeof(req->host),
-                            NULL,
-                            NULL);
-  if (ret == 0) {
-    req->retcode = uv_translate_sys_error(GetLastError());
-    return;
-  }
-
-  ret = WideCharToMultiByte(CP_UTF8,
-                            0,
-                            service,
-                            -1,
-                            req->service,
-                            sizeof(req->service),
-                            NULL,
-                            NULL);
-  if (ret == 0) {
-    req->retcode = uv_translate_sys_error(GetLastError());
-  }
-}
-
-
-/*
-* Called from uv_run when complete.
-*/
-static void uv__getnameinfo_done(struct uv__work* w, int status) {
-  uv_getnameinfo_t* req;
-  char* host;
-  char* service;
-
-  req = container_of(w, uv_getnameinfo_t, work_req);
-  uv__req_unregister(req->loop, req);
-  host = service = NULL;
-
-  if (status == UV_ECANCELED) {
-    assert(req->retcode == 0);
-    req->retcode = UV_EAI_CANCELED;
-  } else if (req->retcode == 0) {
-    host = req->host;
-    service = req->service;
-  }
-
-  if (req->getnameinfo_cb)
-    req->getnameinfo_cb(req, req->retcode, host, service);
-}
-
-
-/*
-* Entry point for getnameinfo
-* return 0 if a callback will be made
-* return error code if validation fails
-*/
-int uv_getnameinfo(uv_loop_t* loop,
-                   uv_getnameinfo_t* req,
-                   uv_getnameinfo_cb getnameinfo_cb,
-                   const struct sockaddr* addr,
-                   int flags) {
-  if (req == NULL || addr == NULL)
-    return UV_EINVAL;
-
-  if (addr->sa_family == AF_INET) {
-    memcpy(&req->storage,
-           addr,
-           sizeof(struct sockaddr_in));
-  } else if (addr->sa_family == AF_INET6) {
-    memcpy(&req->storage,
-           addr,
-           sizeof(struct sockaddr_in6));
-  } else {
-    return UV_EINVAL;
-  }
-
-  UV_REQ_INIT(req, UV_GETNAMEINFO);
-  uv__req_register(loop, req);
-
-  req->getnameinfo_cb = getnameinfo_cb;
-  req->flags = flags;
-  req->loop = loop;
-  req->retcode = 0;
-
-  if (getnameinfo_cb) {
-    uv__work_submit(loop,
-                    &req->work_req,
-                    UV__WORK_SLOW_IO,
-                    uv__getnameinfo_work,
-                    uv__getnameinfo_done);
-    return 0;
-  } else {
-    uv__getnameinfo_work(&req->work_req);
-    uv__getnameinfo_done(&req->work_req, 0);
-    return req->retcode;
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/handle-inl.h b/wpiutil/src/main/native/libuv/src/win/handle-inl.h
deleted file mode 100644
index 82c657d..0000000
--- a/wpiutil/src/main/native/libuv/src/win/handle-inl.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_HANDLE_INL_H_
-#define UV_WIN_HANDLE_INL_H_
-
-#include <assert.h>
-#include <io.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-#define DECREASE_ACTIVE_COUNT(loop, handle)                             \
-  do {                                                                  \
-    if (--(handle)->activecnt == 0 &&                                   \
-        !((handle)->flags & UV_HANDLE_CLOSING)) {                       \
-      uv__handle_stop((handle));                                        \
-    }                                                                   \
-    assert((handle)->activecnt >= 0);                                   \
-  } while (0)
-
-
-#define INCREASE_ACTIVE_COUNT(loop, handle)                             \
-  do {                                                                  \
-    if ((handle)->activecnt++ == 0) {                                   \
-      uv__handle_start((handle));                                       \
-    }                                                                   \
-    assert((handle)->activecnt > 0);                                    \
-  } while (0)
-
-
-#define DECREASE_PENDING_REQ_COUNT(handle)                              \
-  do {                                                                  \
-    assert(handle->reqs_pending > 0);                                   \
-    handle->reqs_pending--;                                             \
-                                                                        \
-    if (handle->flags & UV_HANDLE_CLOSING &&                            \
-        handle->reqs_pending == 0) {                                    \
-      uv_want_endgame(loop, (uv_handle_t*)handle);                      \
-    }                                                                   \
-  } while (0)
-
-
-#define uv__handle_closing(handle)                                      \
-  do {                                                                  \
-    assert(!((handle)->flags & UV_HANDLE_CLOSING));                     \
-                                                                        \
-    if (!(((handle)->flags & UV_HANDLE_ACTIVE) &&                       \
-          ((handle)->flags & UV_HANDLE_REF)))                           \
-      uv__active_handle_add((uv_handle_t*) (handle));                   \
-                                                                        \
-    (handle)->flags |= UV_HANDLE_CLOSING;                               \
-    (handle)->flags &= ~UV_HANDLE_ACTIVE;                               \
-  } while (0)
-
-
-#define uv__handle_close(handle)                                        \
-  do {                                                                  \
-    QUEUE_REMOVE(&(handle)->handle_queue);                              \
-    uv__active_handle_rm((uv_handle_t*) (handle));                      \
-                                                                        \
-    (handle)->flags |= UV_HANDLE_CLOSED;                                \
-                                                                        \
-    if ((handle)->close_cb)                                             \
-      (handle)->close_cb((uv_handle_t*) (handle));                      \
-  } while (0)
-
-
-INLINE static void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle) {
-  if (!(handle->flags & UV_HANDLE_ENDGAME_QUEUED)) {
-    handle->flags |= UV_HANDLE_ENDGAME_QUEUED;
-
-    handle->endgame_next = loop->endgame_handles;
-    loop->endgame_handles = handle;
-  }
-}
-
-
-INLINE static void uv_process_endgames(uv_loop_t* loop) {
-  uv_handle_t* handle;
-
-  while (loop->endgame_handles) {
-    handle = loop->endgame_handles;
-    loop->endgame_handles = handle->endgame_next;
-
-    handle->flags &= ~UV_HANDLE_ENDGAME_QUEUED;
-
-    switch (handle->type) {
-      case UV_TCP:
-        uv_tcp_endgame(loop, (uv_tcp_t*) handle);
-        break;
-
-      case UV_NAMED_PIPE:
-        uv_pipe_endgame(loop, (uv_pipe_t*) handle);
-        break;
-
-      case UV_TTY:
-        uv_tty_endgame(loop, (uv_tty_t*) handle);
-        break;
-
-      case UV_UDP:
-        uv_udp_endgame(loop, (uv_udp_t*) handle);
-        break;
-
-      case UV_POLL:
-        uv_poll_endgame(loop, (uv_poll_t*) handle);
-        break;
-
-      case UV_TIMER:
-        uv__timer_close((uv_timer_t*) handle);
-        uv__handle_close(handle);
-        break;
-
-      case UV_PREPARE:
-      case UV_CHECK:
-      case UV_IDLE:
-        uv_loop_watcher_endgame(loop, handle);
-        break;
-
-      case UV_ASYNC:
-        uv_async_endgame(loop, (uv_async_t*) handle);
-        break;
-
-      case UV_SIGNAL:
-        uv_signal_endgame(loop, (uv_signal_t*) handle);
-        break;
-
-      case UV_PROCESS:
-        uv_process_endgame(loop, (uv_process_t*) handle);
-        break;
-
-      case UV_FS_EVENT:
-        uv_fs_event_endgame(loop, (uv_fs_event_t*) handle);
-        break;
-
-      case UV_FS_POLL:
-        uv__fs_poll_endgame(loop, (uv_fs_poll_t*) handle);
-        break;
-
-      default:
-        assert(0);
-        break;
-    }
-  }
-}
-
-INLINE static HANDLE uv__get_osfhandle(int fd)
-{
-  /* _get_osfhandle() raises an assert in debug builds if the FD is invalid.
-   * But it also correctly checks the FD and returns INVALID_HANDLE_VALUE for
-   * invalid FDs in release builds (or if you let the assert continue). So this
-   * wrapper function disables asserts when calling _get_osfhandle. */
-
-  HANDLE handle;
-  UV_BEGIN_DISABLE_CRT_ASSERT();
-  handle = (HANDLE) _get_osfhandle(fd);
-  UV_END_DISABLE_CRT_ASSERT();
-  return handle;
-}
-
-#endif /* UV_WIN_HANDLE_INL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/handle.cpp b/wpiutil/src/main/native/libuv/src/win/handle.cpp
deleted file mode 100644
index 61e4df6..0000000
--- a/wpiutil/src/main/native/libuv/src/win/handle.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <io.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-
-
-uv_handle_type uv_guess_handle(uv_file file) {
-  HANDLE handle;
-  DWORD mode;
-
-  if (file < 0) {
-    return UV_UNKNOWN_HANDLE;
-  }
-
-  handle = uv__get_osfhandle(file);
-
-  switch (GetFileType(handle)) {
-    case FILE_TYPE_CHAR:
-      if (GetConsoleMode(handle, &mode)) {
-        return UV_TTY;
-      } else {
-        return UV_FILE;
-      }
-
-    case FILE_TYPE_PIPE:
-      return UV_NAMED_PIPE;
-
-    case FILE_TYPE_DISK:
-      return UV_FILE;
-
-    default:
-      return UV_UNKNOWN_HANDLE;
-  }
-}
-
-
-int uv_is_active(const uv_handle_t* handle) {
-  return (handle->flags & UV_HANDLE_ACTIVE) &&
-        !(handle->flags & UV_HANDLE_CLOSING);
-}
-
-
-void uv_close(uv_handle_t* handle, uv_close_cb cb) {
-  uv_loop_t* loop = handle->loop;
-
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    assert(0);
-    return;
-  }
-
-  handle->close_cb = cb;
-
-  /* Handle-specific close actions */
-  switch (handle->type) {
-    case UV_TCP:
-      uv_tcp_close(loop, (uv_tcp_t*)handle);
-      return;
-
-    case UV_NAMED_PIPE:
-      uv_pipe_close(loop, (uv_pipe_t*) handle);
-      return;
-
-    case UV_TTY:
-      uv_tty_close((uv_tty_t*) handle);
-      return;
-
-    case UV_UDP:
-      uv_udp_close(loop, (uv_udp_t*) handle);
-      return;
-
-    case UV_POLL:
-      uv_poll_close(loop, (uv_poll_t*) handle);
-      return;
-
-    case UV_TIMER:
-      uv_timer_stop((uv_timer_t*)handle);
-      uv__handle_closing(handle);
-      uv_want_endgame(loop, handle);
-      return;
-
-    case UV_PREPARE:
-      uv_prepare_stop((uv_prepare_t*)handle);
-      uv__handle_closing(handle);
-      uv_want_endgame(loop, handle);
-      return;
-
-    case UV_CHECK:
-      uv_check_stop((uv_check_t*)handle);
-      uv__handle_closing(handle);
-      uv_want_endgame(loop, handle);
-      return;
-
-    case UV_IDLE:
-      uv_idle_stop((uv_idle_t*)handle);
-      uv__handle_closing(handle);
-      uv_want_endgame(loop, handle);
-      return;
-
-    case UV_ASYNC:
-      uv_async_close(loop, (uv_async_t*) handle);
-      return;
-
-    case UV_SIGNAL:
-      uv_signal_close(loop, (uv_signal_t*) handle);
-      return;
-
-    case UV_PROCESS:
-      uv_process_close(loop, (uv_process_t*) handle);
-      return;
-
-    case UV_FS_EVENT:
-      uv_fs_event_close(loop, (uv_fs_event_t*) handle);
-      return;
-
-    case UV_FS_POLL:
-      uv__fs_poll_close((uv_fs_poll_t*) handle);
-      uv__handle_closing(handle);
-      return;
-
-    default:
-      /* Not supported */
-      abort();
-  }
-}
-
-
-int uv_is_closing(const uv_handle_t* handle) {
-  return !!(handle->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED));
-}
-
-
-uv_os_fd_t uv_get_osfhandle(int fd) {
-  return uv__get_osfhandle(fd);
-}
-
-int uv_open_osfhandle(uv_os_fd_t os_fd) {
-  return _open_osfhandle((intptr_t) os_fd, 0);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/internal.h b/wpiutil/src/main/native/libuv/src/win/internal.h
deleted file mode 100644
index 70ddaa5..0000000
--- a/wpiutil/src/main/native/libuv/src/win/internal.h
+++ /dev/null
@@ -1,342 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_INTERNAL_H_
-#define UV_WIN_INTERNAL_H_
-
-#include "uv.h"
-#include "../uv-common.h"
-
-#include "uv/tree.h"
-#include "winapi.h"
-#include "winsock.h"
-
-#ifdef _MSC_VER
-# define INLINE __inline
-# define UV_THREAD_LOCAL __declspec( thread )
-#else
-# define INLINE inline
-# define UV_THREAD_LOCAL __thread
-#endif
-
-
-#ifdef _DEBUG
-
-extern UV_THREAD_LOCAL int uv__crt_assert_enabled;
-
-#define UV_BEGIN_DISABLE_CRT_ASSERT()                           \
-  {                                                             \
-    int uv__saved_crt_assert_enabled = uv__crt_assert_enabled;  \
-    uv__crt_assert_enabled = FALSE;
-
-
-#define UV_END_DISABLE_CRT_ASSERT()                             \
-    uv__crt_assert_enabled = uv__saved_crt_assert_enabled;      \
-  }
-
-#else
-#define UV_BEGIN_DISABLE_CRT_ASSERT()
-#define UV_END_DISABLE_CRT_ASSERT()
-#endif
-
-/*
- * TCP
- */
-
-typedef enum {
-  UV__IPC_SOCKET_XFER_NONE = 0,
-  UV__IPC_SOCKET_XFER_TCP_CONNECTION,
-  UV__IPC_SOCKET_XFER_TCP_SERVER
-} uv__ipc_socket_xfer_type_t;
-
-typedef struct {
-  WSAPROTOCOL_INFOW socket_info;
-  uint32_t delayed_error;
-} uv__ipc_socket_xfer_info_t;
-
-int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb);
-int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client);
-int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb);
-int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
-    const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
-int uv__tcp_try_write(uv_tcp_t* handle, const uv_buf_t bufs[],
-    unsigned int nbufs);
-
-void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, uv_req_t* req);
-void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_write_t* req);
-void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_req_t* req);
-void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_connect_t* req);
-
-void uv_tcp_close(uv_loop_t* loop, uv_tcp_t* tcp);
-void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle);
-
-int uv__tcp_xfer_export(uv_tcp_t* handle,
-                        int pid,
-                        uv__ipc_socket_xfer_type_t* xfer_type,
-                        uv__ipc_socket_xfer_info_t* xfer_info);
-int uv__tcp_xfer_import(uv_tcp_t* tcp,
-                        uv__ipc_socket_xfer_type_t xfer_type,
-                        uv__ipc_socket_xfer_info_t* xfer_info);
-
-
-/*
- * UDP
- */
-void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req);
-void uv_process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
-    uv_udp_send_t* req);
-
-void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle);
-void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle);
-
-
-/*
- * Pipes
- */
-int uv_stdio_pipe_server(uv_loop_t* loop, uv_pipe_t* handle, DWORD access,
-    char* name, size_t nameSize);
-
-int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
-int uv_pipe_accept(uv_pipe_t* server, uv_stream_t* client);
-int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb);
-void uv__pipe_read_stop(uv_pipe_t* handle);
-int uv__pipe_write(uv_loop_t* loop,
-                   uv_write_t* req,
-                   uv_pipe_t* handle,
-                   const uv_buf_t bufs[],
-                   size_t nbufs,
-                   uv_stream_t* send_handle,
-                   uv_write_cb cb);
-
-void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_req_t* req);
-void uv_process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_write_t* req);
-void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_req_t* raw_req);
-void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_connect_t* req);
-void uv_process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_shutdown_t* req);
-
-void uv_pipe_close(uv_loop_t* loop, uv_pipe_t* handle);
-void uv_pipe_cleanup(uv_loop_t* loop, uv_pipe_t* handle);
-void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle);
-
-
-/*
- * TTY
- */
-void uv_console_init(void);
-
-int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb);
-int uv_tty_read_stop(uv_tty_t* handle);
-int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
-    const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
-int uv__tty_try_write(uv_tty_t* handle, const uv_buf_t bufs[],
-    unsigned int nbufs);
-void uv_tty_close(uv_tty_t* handle);
-
-void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* req);
-void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_write_t* req);
-/*
- * uv_process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working
- * TODO: find a way to remove it
- */
-void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* raw_req);
-/*
- * uv_process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working
- * TODO: find a way to remove it
- */
-void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_connect_t* req);
-
-void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle);
-
-
-/*
- * Poll watchers
- */
-void uv_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
-    uv_req_t* req);
-
-int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle);
-void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle);
-
-
-/*
- * Loop watchers
- */
-void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle);
-
-void uv_prepare_invoke(uv_loop_t* loop);
-void uv_check_invoke(uv_loop_t* loop);
-void uv_idle_invoke(uv_loop_t* loop);
-
-void uv__once_init(void);
-
-
-/*
- * Async watcher
- */
-void uv_async_close(uv_loop_t* loop, uv_async_t* handle);
-void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle);
-
-void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
-    uv_req_t* req);
-
-
-/*
- * Signal watcher
- */
-void uv_signals_init(void);
-int uv__signal_dispatch(int signum);
-
-void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle);
-void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle);
-
-void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
-    uv_req_t* req);
-
-
-/*
- * Spawn
- */
-void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle);
-void uv_process_close(uv_loop_t* loop, uv_process_t* handle);
-void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle);
-
-
-/*
- * Error
- */
-int uv_translate_sys_error(int sys_errno);
-
-
-/*
- * FS
- */
-void uv_fs_init(void);
-
-
-/*
- * FS Event
- */
-void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
-    uv_fs_event_t* handle);
-void uv_fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle);
-void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle);
-
-
-/*
- * Stat poller.
- */
-void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle);
-
-
-/*
- * Utilities.
- */
-void uv__util_init(void);
-
-uint64_t uv__hrtime(double scale);
-__declspec(noreturn) void uv_fatal_error(const int errorno, const char* syscall);
-int uv__getpwuid_r(uv_passwd_t* pwd);
-int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8);
-int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16);
-
-typedef int (WINAPI *uv__peersockfunc)(SOCKET, struct sockaddr*, int*);
-
-int uv__getsockpeername(const uv_handle_t* handle,
-                        uv__peersockfunc func,
-                        struct sockaddr* name,
-                        int* namelen,
-                        int delayed_error);
-
-
-/*
- * Process stdio handles.
- */
-int uv__stdio_create(uv_loop_t* loop,
-                     const uv_process_options_t* options,
-                     BYTE** buffer_ptr);
-void uv__stdio_destroy(BYTE* buffer);
-void uv__stdio_noinherit(BYTE* buffer);
-int uv__stdio_verify(BYTE* buffer, WORD size);
-WORD uv__stdio_size(BYTE* buffer);
-HANDLE uv__stdio_handle(BYTE* buffer, int fd);
-
-
-/*
- * Winapi and ntapi utility functions
- */
-void uv_winapi_init(void);
-
-
-/*
- * Winsock utility functions
- */
-void uv_winsock_init(void);
-
-int uv_ntstatus_to_winsock_error(NTSTATUS status);
-
-BOOL uv_get_acceptex_function(SOCKET socket, LPFN_ACCEPTEX* target);
-BOOL uv_get_connectex_function(SOCKET socket, LPFN_CONNECTEX* target);
-
-int WSAAPI uv_wsarecv_workaround(SOCKET socket, WSABUF* buffers,
-    DWORD buffer_count, DWORD* bytes, DWORD* flags, WSAOVERLAPPED *overlapped,
-    LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
-int WSAAPI uv_wsarecvfrom_workaround(SOCKET socket, WSABUF* buffers,
-    DWORD buffer_count, DWORD* bytes, DWORD* flags, struct sockaddr* addr,
-    int* addr_len, WSAOVERLAPPED *overlapped,
-    LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
-
-int WSAAPI uv_msafd_poll(SOCKET socket, AFD_POLL_INFO* info_in,
-    AFD_POLL_INFO* info_out, OVERLAPPED* overlapped);
-
-/* Whether there are any non-IFS LSPs stacked on TCP */
-extern int uv_tcp_non_ifs_lsp_ipv4;
-extern int uv_tcp_non_ifs_lsp_ipv6;
-
-/* Ip address used to bind to any port at any interface */
-extern struct sockaddr_in uv_addr_ip4_any_;
-extern struct sockaddr_in6 uv_addr_ip6_any_;
-
-/*
- * Wake all loops with fake message
- */
-void uv__wake_all_loops(void);
-
-/*
- * Init system wake-up detection
- */
-void uv__init_detect_system_wakeup(void);
-
-#endif /* UV_WIN_INTERNAL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/loop-watcher.cpp b/wpiutil/src/main/native/libuv/src/win/loop-watcher.cpp
deleted file mode 100644
index ad7fbea..0000000
--- a/wpiutil/src/main/native/libuv/src/win/loop-watcher.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-
-
-void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle) {
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-    handle->flags |= UV_HANDLE_CLOSED;
-    uv__handle_close(handle);
-  }
-}
-
-
-#define UV_LOOP_WATCHER_DEFINE(name, NAME)                                    \
-  int uv_##name##_init(uv_loop_t* loop, uv_##name##_t* handle) {              \
-    uv__handle_init(loop, (uv_handle_t*) handle, UV_##NAME);                  \
-                                                                              \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-                                                                              \
-  int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) {           \
-    uv_loop_t* loop = handle->loop;                                           \
-    uv_##name##_t* old_head;                                                  \
-                                                                              \
-    assert(handle->type == UV_##NAME);                                        \
-                                                                              \
-    if (uv__is_active(handle))                                                \
-      return 0;                                                               \
-                                                                              \
-    if (cb == NULL)                                                           \
-      return UV_EINVAL;                                                       \
-                                                                              \
-    old_head = loop->name##_handles;                                          \
-                                                                              \
-    handle->name##_next = old_head;                                           \
-    handle->name##_prev = NULL;                                               \
-                                                                              \
-    if (old_head) {                                                           \
-      old_head->name##_prev = handle;                                         \
-    }                                                                         \
-                                                                              \
-    loop->name##_handles = handle;                                            \
-                                                                              \
-    handle->name##_cb = cb;                                                   \
-    uv__handle_start(handle);                                                 \
-                                                                              \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-                                                                              \
-  int uv_##name##_stop(uv_##name##_t* handle) {                               \
-    uv_loop_t* loop = handle->loop;                                           \
-                                                                              \
-    assert(handle->type == UV_##NAME);                                        \
-                                                                              \
-    if (!uv__is_active(handle))                                               \
-      return 0;                                                               \
-                                                                              \
-    /* Update loop head if needed */                                          \
-    if (loop->name##_handles == handle) {                                     \
-      loop->name##_handles = handle->name##_next;                             \
-    }                                                                         \
-                                                                              \
-    /* Update the iterator-next pointer of needed */                          \
-    if (loop->next_##name##_handle == handle) {                               \
-      loop->next_##name##_handle = handle->name##_next;                       \
-    }                                                                         \
-                                                                              \
-    if (handle->name##_prev) {                                                \
-      handle->name##_prev->name##_next = handle->name##_next;                 \
-    }                                                                         \
-    if (handle->name##_next) {                                                \
-      handle->name##_next->name##_prev = handle->name##_prev;                 \
-    }                                                                         \
-                                                                              \
-    uv__handle_stop(handle);                                                  \
-                                                                              \
-    return 0;                                                                 \
-  }                                                                           \
-                                                                              \
-                                                                              \
-  void uv_##name##_invoke(uv_loop_t* loop) {                                  \
-    uv_##name##_t* handle;                                                    \
-                                                                              \
-    (loop)->next_##name##_handle = (loop)->name##_handles;                    \
-                                                                              \
-    while ((loop)->next_##name##_handle != NULL) {                            \
-      handle = (loop)->next_##name##_handle;                                  \
-      (loop)->next_##name##_handle = handle->name##_next;                     \
-                                                                              \
-      handle->name##_cb(handle);                                              \
-    }                                                                         \
-  }
-
-UV_LOOP_WATCHER_DEFINE(prepare, PREPARE)
-UV_LOOP_WATCHER_DEFINE(check, CHECK)
-UV_LOOP_WATCHER_DEFINE(idle, IDLE)
diff --git a/wpiutil/src/main/native/libuv/src/win/pipe.cpp b/wpiutil/src/main/native/libuv/src/win/pipe.cpp
deleted file mode 100644
index 0c03a06..0000000
--- a/wpiutil/src/main/native/libuv/src/win/pipe.cpp
+++ /dev/null
@@ -1,2388 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#define _CRT_NONSTDC_NO_WARNINGS
-
-#include <assert.h>
-#include <io.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "handle-inl.h"
-#include "internal.h"
-#include "req-inl.h"
-#include "stream-inl.h"
-#include "uv-common.h"
-#include "uv.h"
-
-#include <aclapi.h>
-#include <accctrl.h>
-
-/* A zero-size buffer for use by uv_pipe_read */
-static char uv_zero_[] = "";
-
-/* Null uv_buf_t */
-static const uv_buf_t uv_null_buf_ = { 0, NULL };
-
-/* The timeout that the pipe will wait for the remote end to write data when
- * the local ends wants to shut it down. */
-static const int64_t eof_timeout = 50; /* ms */
-
-static const int default_pending_pipe_instances = 4;
-
-/* Pipe prefix */
-static char pipe_prefix[] = "\\\\?\\pipe";
-static const int pipe_prefix_len = sizeof(pipe_prefix) - 1;
-
-/* IPC incoming xfer queue item. */
-typedef struct {
-  uv__ipc_socket_xfer_type_t xfer_type;
-  uv__ipc_socket_xfer_info_t xfer_info;
-  QUEUE member;
-} uv__ipc_xfer_queue_item_t;
-
-/* IPC frame header flags. */
-/* clang-format off */
-enum {
-  UV__IPC_FRAME_HAS_DATA                = 0x01,
-  UV__IPC_FRAME_HAS_SOCKET_XFER         = 0x02,
-  UV__IPC_FRAME_XFER_IS_TCP_CONNECTION  = 0x04,
-  /* These are combinations of the flags above. */
-  UV__IPC_FRAME_XFER_FLAGS              = 0x06,
-  UV__IPC_FRAME_VALID_FLAGS             = 0x07
-};
-/* clang-format on */
-
-/* IPC frame header. */
-typedef struct {
-  uint32_t flags;
-  uint32_t reserved1;   /* Ignored. */
-  uint32_t data_length; /* Must be zero if there is no data. */
-  uint32_t reserved2;   /* Must be zero. */
-} uv__ipc_frame_header_t;
-
-/* To implement the IPC protocol correctly, these structures must have exactly
- * the right size. */
-STATIC_ASSERT(sizeof(uv__ipc_frame_header_t) == 16);
-STATIC_ASSERT(sizeof(uv__ipc_socket_xfer_info_t) == 632);
-
-/* Coalesced write request. */
-typedef struct {
-  uv_write_t req;       /* Internal heap-allocated write request. */
-  uv_write_t* user_req; /* Pointer to user-specified uv_write_t. */
-} uv__coalesced_write_t;
-
-
-static void eof_timer_init(uv_pipe_t* pipe);
-static void eof_timer_start(uv_pipe_t* pipe);
-static void eof_timer_stop(uv_pipe_t* pipe);
-static void eof_timer_cb(uv_timer_t* timer);
-static void eof_timer_destroy(uv_pipe_t* pipe);
-static void eof_timer_close_cb(uv_handle_t* handle);
-
-
-static void uv_unique_pipe_name(char* ptr, char* name, size_t size) {
-  snprintf(name, size, "\\\\?\\pipe\\uv\\%p-%lu", ptr, GetCurrentProcessId());
-}
-
-
-int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) {
-  uv_stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
-
-  handle->reqs_pending = 0;
-  handle->handle = INVALID_HANDLE_VALUE;
-  handle->name = NULL;
-  handle->pipe.conn.ipc_remote_pid = 0;
-  handle->pipe.conn.ipc_data_frame.payload_remaining = 0;
-  QUEUE_INIT(&handle->pipe.conn.ipc_xfer_queue);
-  handle->pipe.conn.ipc_xfer_queue_length = 0;
-  handle->ipc = ipc;
-  handle->pipe.conn.non_overlapped_writes_tail = NULL;
-
-  return 0;
-}
-
-
-static void uv_pipe_connection_init(uv_pipe_t* handle) {
-  uv_connection_init((uv_stream_t*) handle);
-  handle->read_req.data = handle;
-  handle->pipe.conn.eof_timer = NULL;
-  assert(!(handle->flags & UV_HANDLE_PIPESERVER));
-  if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) {
-    handle->pipe.conn.readfile_thread_handle = NULL;
-    InitializeCriticalSection(&handle->pipe.conn.readfile_thread_lock);
-  }
-}
-
-
-static HANDLE open_named_pipe(const WCHAR* name, DWORD* duplex_flags) {
-  HANDLE pipeHandle;
-
-  /*
-   * Assume that we have a duplex pipe first, so attempt to
-   * connect with GENERIC_READ | GENERIC_WRITE.
-   */
-  pipeHandle = CreateFileW(name,
-                           GENERIC_READ | GENERIC_WRITE,
-                           0,
-                           NULL,
-                           OPEN_EXISTING,
-                           FILE_FLAG_OVERLAPPED,
-                           NULL);
-  if (pipeHandle != INVALID_HANDLE_VALUE) {
-    *duplex_flags = UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-    return pipeHandle;
-  }
-
-  /*
-   * If the pipe is not duplex CreateFileW fails with
-   * ERROR_ACCESS_DENIED.  In that case try to connect
-   * as a read-only or write-only.
-   */
-  if (GetLastError() == ERROR_ACCESS_DENIED) {
-    pipeHandle = CreateFileW(name,
-                             GENERIC_READ | FILE_WRITE_ATTRIBUTES,
-                             0,
-                             NULL,
-                             OPEN_EXISTING,
-                             FILE_FLAG_OVERLAPPED,
-                             NULL);
-
-    if (pipeHandle != INVALID_HANDLE_VALUE) {
-      *duplex_flags = UV_HANDLE_READABLE;
-      return pipeHandle;
-    }
-  }
-
-  if (GetLastError() == ERROR_ACCESS_DENIED) {
-    pipeHandle = CreateFileW(name,
-                             GENERIC_WRITE | FILE_READ_ATTRIBUTES,
-                             0,
-                             NULL,
-                             OPEN_EXISTING,
-                             FILE_FLAG_OVERLAPPED,
-                             NULL);
-
-    if (pipeHandle != INVALID_HANDLE_VALUE) {
-      *duplex_flags = UV_HANDLE_WRITABLE;
-      return pipeHandle;
-    }
-  }
-
-  return INVALID_HANDLE_VALUE;
-}
-
-
-static void close_pipe(uv_pipe_t* pipe) {
-  assert(pipe->u.fd == -1 || pipe->u.fd > 2);
-  if (pipe->u.fd == -1)
-    CloseHandle(pipe->handle);
-  else
-    close(pipe->u.fd);
-
-  pipe->u.fd = -1;
-  pipe->handle = INVALID_HANDLE_VALUE;
-}
-
-
-int uv_stdio_pipe_server(uv_loop_t* loop, uv_pipe_t* handle, DWORD access,
-    char* name, size_t nameSize) {
-  HANDLE pipeHandle;
-  int err;
-  char* ptr = (char*)handle;
-
-  for (;;) {
-    uv_unique_pipe_name(ptr, name, nameSize);
-
-    pipeHandle = CreateNamedPipeA(name,
-      access | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE | WRITE_DAC,
-      PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 65536, 65536, 0,
-      NULL);
-
-    if (pipeHandle != INVALID_HANDLE_VALUE) {
-      /* No name collisions.  We're done. */
-      break;
-    }
-
-    err = GetLastError();
-    if (err != ERROR_PIPE_BUSY && err != ERROR_ACCESS_DENIED) {
-      goto error;
-    }
-
-    /* Pipe name collision.  Increment the pointer and try again. */
-    ptr++;
-  }
-
-  if (CreateIoCompletionPort(pipeHandle,
-                             loop->iocp,
-                             (ULONG_PTR)handle,
-                             0) == NULL) {
-    err = GetLastError();
-    goto error;
-  }
-
-  uv_pipe_connection_init(handle);
-  handle->handle = pipeHandle;
-
-  return 0;
-
- error:
-  if (pipeHandle != INVALID_HANDLE_VALUE) {
-    CloseHandle(pipeHandle);
-  }
-
-  return err;
-}
-
-
-static int uv_set_pipe_handle(uv_loop_t* loop,
-                              uv_pipe_t* handle,
-                              HANDLE pipeHandle,
-                              int fd,
-                              DWORD duplex_flags) {
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-  FILE_MODE_INFORMATION mode_info;
-  DWORD mode = PIPE_READMODE_BYTE | PIPE_WAIT;
-  DWORD current_mode = 0;
-  DWORD err = 0;
-
-  if (!(handle->flags & UV_HANDLE_PIPESERVER) &&
-      handle->handle != INVALID_HANDLE_VALUE)
-    return UV_EBUSY;
-
-  if (!SetNamedPipeHandleState(pipeHandle, &mode, NULL, NULL)) {
-    err = GetLastError();
-    if (err == ERROR_ACCESS_DENIED) {
-      /*
-       * SetNamedPipeHandleState can fail if the handle doesn't have either
-       * GENERIC_WRITE  or FILE_WRITE_ATTRIBUTES.
-       * But if the handle already has the desired wait and blocking modes
-       * we can continue.
-       */
-      if (!GetNamedPipeHandleState(pipeHandle, &current_mode, NULL, NULL,
-                                   NULL, NULL, 0)) {
-        return -1;
-      } else if (current_mode & PIPE_NOWAIT) {
-        SetLastError(ERROR_ACCESS_DENIED);
-        return -1;
-      }
-    } else {
-      /* If this returns ERROR_INVALID_PARAMETER we probably opened
-       * something that is not a pipe. */
-      if (err == ERROR_INVALID_PARAMETER) {
-        SetLastError(WSAENOTSOCK);
-      }
-      return -1;
-    }
-  }
-
-  /* Check if the pipe was created with FILE_FLAG_OVERLAPPED. */
-  nt_status = pNtQueryInformationFile(pipeHandle,
-                                      &io_status,
-                                      &mode_info,
-                                      sizeof(mode_info),
-                                      FileModeInformation);
-  if (nt_status != STATUS_SUCCESS) {
-    return -1;
-  }
-
-  if (mode_info.Mode & FILE_SYNCHRONOUS_IO_ALERT ||
-      mode_info.Mode & FILE_SYNCHRONOUS_IO_NONALERT) {
-    /* Non-overlapped pipe. */
-    handle->flags |= UV_HANDLE_NON_OVERLAPPED_PIPE;
-  } else {
-    /* Overlapped pipe.  Try to associate with IOCP. */
-    if (CreateIoCompletionPort(pipeHandle,
-                               loop->iocp,
-                               (ULONG_PTR)handle,
-                               0) == NULL) {
-      handle->flags |= UV_HANDLE_EMULATE_IOCP;
-    }
-  }
-
-  handle->handle = pipeHandle;
-  handle->u.fd = fd;
-  handle->flags |= duplex_flags;
-
-  return 0;
-}
-
-
-static DWORD WINAPI pipe_shutdown_thread_proc(void* parameter) {
-  uv_loop_t* loop;
-  uv_pipe_t* handle;
-  uv_shutdown_t* req;
-
-  req = (uv_shutdown_t*) parameter;
-  assert(req);
-  handle = (uv_pipe_t*) req->handle;
-  assert(handle);
-  loop = handle->loop;
-  assert(loop);
-
-  FlushFileBuffers(handle->handle);
-
-  /* Post completed */
-  POST_COMPLETION_FOR_REQ(loop, req);
-
-  return 0;
-}
-
-
-void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
-  int err;
-  DWORD result;
-  uv_shutdown_t* req;
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-  FILE_PIPE_LOCAL_INFORMATION pipe_info;
-  uv__ipc_xfer_queue_item_t* xfer_queue_item;
-
-  if ((handle->flags & UV_HANDLE_CONNECTION) &&
-      handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-    req = handle->stream.conn.shutdown_req;
-
-    /* Clear the shutdown_req field so we don't go here again. */
-    handle->stream.conn.shutdown_req = NULL;
-
-    if (handle->flags & UV_HANDLE_CLOSING) {
-      UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-      /* Already closing. Cancel the shutdown. */
-      if (req->cb) {
-        req->cb(req, UV_ECANCELED);
-      }
-
-      DECREASE_PENDING_REQ_COUNT(handle);
-      return;
-    }
-
-    /* Try to avoid flushing the pipe buffer in the thread pool. */
-    nt_status = pNtQueryInformationFile(handle->handle,
-                                        &io_status,
-                                        &pipe_info,
-                                        sizeof pipe_info,
-                                        FilePipeLocalInformation);
-
-    if (nt_status != STATUS_SUCCESS) {
-      /* Failure */
-      UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-      handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */
-      if (req->cb) {
-        err = pRtlNtStatusToDosError(nt_status);
-        req->cb(req, uv_translate_sys_error(err));
-      }
-
-      DECREASE_PENDING_REQ_COUNT(handle);
-      return;
-    }
-
-    if (pipe_info.OutboundQuota == pipe_info.WriteQuotaAvailable) {
-      /* Short-circuit, no need to call FlushFileBuffers. */
-      uv_insert_pending_req(loop, (uv_req_t*) req);
-      return;
-    }
-
-    /* Run FlushFileBuffers in the thread pool. */
-    result = QueueUserWorkItem(pipe_shutdown_thread_proc,
-                               req,
-                               WT_EXECUTELONGFUNCTION);
-    if (result) {
-      return;
-
-    } else {
-      /* Failure. */
-      UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-      handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */
-      if (req->cb) {
-        err = GetLastError();
-        req->cb(req, uv_translate_sys_error(err));
-      }
-
-      DECREASE_PENDING_REQ_COUNT(handle);
-      return;
-    }
-  }
-
-  if (handle->flags & UV_HANDLE_CLOSING &&
-      handle->reqs_pending == 0) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-    if (handle->flags & UV_HANDLE_CONNECTION) {
-      /* Free pending sockets */
-      while (!QUEUE_EMPTY(&handle->pipe.conn.ipc_xfer_queue)) {
-        QUEUE* q;
-        SOCKET socket;
-
-        q = QUEUE_HEAD(&handle->pipe.conn.ipc_xfer_queue);
-        QUEUE_REMOVE(q);
-        xfer_queue_item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
-
-        /* Materialize socket and close it */
-        socket = WSASocketW(FROM_PROTOCOL_INFO,
-                            FROM_PROTOCOL_INFO,
-                            FROM_PROTOCOL_INFO,
-                            &xfer_queue_item->xfer_info.socket_info,
-                            0,
-                            WSA_FLAG_OVERLAPPED);
-        uv__free(xfer_queue_item);
-
-        if (socket != INVALID_SOCKET)
-          closesocket(socket);
-      }
-      handle->pipe.conn.ipc_xfer_queue_length = 0;
-
-      if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-        if (handle->read_req.wait_handle != INVALID_HANDLE_VALUE) {
-          UnregisterWait(handle->read_req.wait_handle);
-          handle->read_req.wait_handle = INVALID_HANDLE_VALUE;
-        }
-        if (handle->read_req.event_handle) {
-          CloseHandle(handle->read_req.event_handle);
-          handle->read_req.event_handle = NULL;
-        }
-      }
-
-      if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE)
-        DeleteCriticalSection(&handle->pipe.conn.readfile_thread_lock);
-    }
-
-    if (handle->flags & UV_HANDLE_PIPESERVER) {
-      assert(handle->pipe.serv.accept_reqs);
-      uv__free(handle->pipe.serv.accept_reqs);
-      handle->pipe.serv.accept_reqs = NULL;
-    }
-
-    uv__handle_close(handle);
-  }
-}
-
-
-void uv_pipe_pending_instances(uv_pipe_t* handle, int count) {
-  if (handle->flags & UV_HANDLE_BOUND)
-    return;
-  handle->pipe.serv.pending_instances = count;
-  handle->flags |= UV_HANDLE_PIPESERVER;
-}
-
-
-/* Creates a pipe server. */
-int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
-  uv_loop_t* loop = handle->loop;
-  int i, err, nameSize;
-  uv_pipe_accept_t* req;
-
-  if (handle->flags & UV_HANDLE_BOUND) {
-    return UV_EINVAL;
-  }
-
-  if (!name) {
-    return UV_EINVAL;
-  }
-
-  if (!(handle->flags & UV_HANDLE_PIPESERVER)) {
-    handle->pipe.serv.pending_instances = default_pending_pipe_instances;
-  }
-
-  handle->pipe.serv.accept_reqs = (uv_pipe_accept_t*)
-    uv__malloc(sizeof(uv_pipe_accept_t) * handle->pipe.serv.pending_instances);
-  if (!handle->pipe.serv.accept_reqs) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  for (i = 0; i < handle->pipe.serv.pending_instances; i++) {
-    req = &handle->pipe.serv.accept_reqs[i];
-    UV_REQ_INIT(req, UV_ACCEPT);
-    req->data = handle;
-    req->pipeHandle = INVALID_HANDLE_VALUE;
-    req->next_pending = NULL;
-  }
-
-  /* Convert name to UTF16. */
-  nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR);
-  handle->name = (WCHAR*)uv__malloc(nameSize);
-  if (!handle->name) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  if (!MultiByteToWideChar(CP_UTF8,
-                           0,
-                           name,
-                           -1,
-                           handle->name,
-                           nameSize / sizeof(WCHAR))) {
-    err = GetLastError();
-    goto error;
-  }
-
-  /*
-   * Attempt to create the first pipe with FILE_FLAG_FIRST_PIPE_INSTANCE.
-   * If this fails then there's already a pipe server for the given pipe name.
-   */
-  handle->pipe.serv.accept_reqs[0].pipeHandle = CreateNamedPipeW(handle->name,
-      PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
-      FILE_FLAG_FIRST_PIPE_INSTANCE | WRITE_DAC,
-      PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
-      PIPE_UNLIMITED_INSTANCES, 65536, 65536, 0, NULL);
-
-  if (handle->pipe.serv.accept_reqs[0].pipeHandle == INVALID_HANDLE_VALUE) {
-    err = GetLastError();
-    if (err == ERROR_ACCESS_DENIED) {
-      err = WSAEADDRINUSE;  /* Translates to UV_EADDRINUSE. */
-    } else if (err == ERROR_PATH_NOT_FOUND || err == ERROR_INVALID_NAME) {
-      err = WSAEACCES;  /* Translates to UV_EACCES. */
-    }
-    goto error;
-  }
-
-  if (uv_set_pipe_handle(loop,
-                         handle,
-                         handle->pipe.serv.accept_reqs[0].pipeHandle,
-                         -1,
-                         0)) {
-    err = GetLastError();
-    goto error;
-  }
-
-  handle->pipe.serv.pending_accepts = NULL;
-  handle->flags |= UV_HANDLE_PIPESERVER;
-  handle->flags |= UV_HANDLE_BOUND;
-
-  return 0;
-
-error:
-  if (handle->name) {
-    uv__free(handle->name);
-    handle->name = NULL;
-  }
-
-  if (handle->pipe.serv.accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE) {
-    CloseHandle(handle->pipe.serv.accept_reqs[0].pipeHandle);
-    handle->pipe.serv.accept_reqs[0].pipeHandle = INVALID_HANDLE_VALUE;
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-static DWORD WINAPI pipe_connect_thread_proc(void* parameter) {
-  uv_loop_t* loop;
-  uv_pipe_t* handle;
-  uv_connect_t* req;
-  HANDLE pipeHandle = INVALID_HANDLE_VALUE;
-  DWORD duplex_flags;
-
-  req = (uv_connect_t*) parameter;
-  assert(req);
-  handle = (uv_pipe_t*) req->handle;
-  assert(handle);
-  loop = handle->loop;
-  assert(loop);
-
-  /* We're here because CreateFile on a pipe returned ERROR_PIPE_BUSY. We wait
-   * for the pipe to become available with WaitNamedPipe. */
-  while (WaitNamedPipeW(handle->name, 30000)) {
-    /* The pipe is now available, try to connect. */
-    pipeHandle = open_named_pipe(handle->name, &duplex_flags);
-    if (pipeHandle != INVALID_HANDLE_VALUE) {
-      break;
-    }
-
-    SwitchToThread();
-  }
-
-  if (pipeHandle != INVALID_HANDLE_VALUE &&
-      !uv_set_pipe_handle(loop, handle, pipeHandle, -1, duplex_flags)) {
-    SET_REQ_SUCCESS(req);
-  } else {
-    SET_REQ_ERROR(req, GetLastError());
-  }
-
-  /* Post completed */
-  POST_COMPLETION_FOR_REQ(loop, req);
-
-  return 0;
-}
-
-
-void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
-    const char* name, uv_connect_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  int err, nameSize;
-  HANDLE pipeHandle = INVALID_HANDLE_VALUE;
-  DWORD duplex_flags;
-
-  UV_REQ_INIT(req, UV_CONNECT);
-  req->handle = (uv_stream_t*) handle;
-  req->cb = cb;
-
-  /* Convert name to UTF16. */
-  nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR);
-  handle->name = (WCHAR*)uv__malloc(nameSize);
-  if (!handle->name) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  if (!MultiByteToWideChar(CP_UTF8,
-                           0,
-                           name,
-                           -1,
-                           handle->name,
-                           nameSize / sizeof(WCHAR))) {
-    err = GetLastError();
-    goto error;
-  }
-
-  pipeHandle = open_named_pipe(handle->name, &duplex_flags);
-  if (pipeHandle == INVALID_HANDLE_VALUE) {
-    if (GetLastError() == ERROR_PIPE_BUSY) {
-      /* Wait for the server to make a pipe instance available. */
-      if (!QueueUserWorkItem(&pipe_connect_thread_proc,
-                             req,
-                             WT_EXECUTELONGFUNCTION)) {
-        err = GetLastError();
-        goto error;
-      }
-
-      REGISTER_HANDLE_REQ(loop, handle, req);
-      handle->reqs_pending++;
-
-      return;
-    }
-
-    err = GetLastError();
-    goto error;
-  }
-
-  assert(pipeHandle != INVALID_HANDLE_VALUE);
-
-  if (uv_set_pipe_handle(loop,
-                         (uv_pipe_t*) req->handle,
-                         pipeHandle,
-                         -1,
-                         duplex_flags)) {
-    err = GetLastError();
-    goto error;
-  }
-
-  SET_REQ_SUCCESS(req);
-  uv_insert_pending_req(loop, (uv_req_t*) req);
-  handle->reqs_pending++;
-  REGISTER_HANDLE_REQ(loop, handle, req);
-  return;
-
-error:
-  if (handle->name) {
-    uv__free(handle->name);
-    handle->name = NULL;
-  }
-
-  if (pipeHandle != INVALID_HANDLE_VALUE) {
-    CloseHandle(pipeHandle);
-  }
-
-  /* Make this req pending reporting an error. */
-  SET_REQ_ERROR(req, err);
-  uv_insert_pending_req(loop, (uv_req_t*) req);
-  handle->reqs_pending++;
-  REGISTER_HANDLE_REQ(loop, handle, req);
-  return;
-}
-
-
-void uv__pipe_interrupt_read(uv_pipe_t* handle) {
-  BOOL r;
-
-  if (!(handle->flags & UV_HANDLE_READ_PENDING))
-    return; /* No pending reads. */
-  if (handle->flags & UV_HANDLE_CANCELLATION_PENDING)
-    return; /* Already cancelled. */
-  if (handle->handle == INVALID_HANDLE_VALUE)
-    return; /* Pipe handle closed. */
-
-  if (!(handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE)) {
-    /* Cancel asynchronous read. */
-    r = CancelIoEx(handle->handle, &handle->read_req.u.io.overlapped);
-    assert(r || GetLastError() == ERROR_NOT_FOUND);
-
-  } else {
-    /* Cancel synchronous read (which is happening in the thread pool). */
-    HANDLE thread;
-    volatile HANDLE* thread_ptr = &handle->pipe.conn.readfile_thread_handle;
-
-    EnterCriticalSection(&handle->pipe.conn.readfile_thread_lock);
-
-    thread = *thread_ptr;
-    if (thread == NULL) {
-      /* The thread pool thread has not yet reached the point of blocking, we
-       * can pre-empt it by setting thread_handle to INVALID_HANDLE_VALUE. */
-      *thread_ptr = INVALID_HANDLE_VALUE;
-
-    } else {
-      /* Spin until the thread has acknowledged (by setting the thread to
-       * INVALID_HANDLE_VALUE) that it is past the point of blocking. */
-      while (thread != INVALID_HANDLE_VALUE) {
-        r = CancelSynchronousIo(thread);
-        assert(r || GetLastError() == ERROR_NOT_FOUND);
-        SwitchToThread(); /* Yield thread. */
-        thread = *thread_ptr;
-      }
-    }
-
-    LeaveCriticalSection(&handle->pipe.conn.readfile_thread_lock);
-  }
-
-  /* Set flag to indicate that read has been cancelled. */
-  handle->flags |= UV_HANDLE_CANCELLATION_PENDING;
-}
-
-
-void uv__pipe_read_stop(uv_pipe_t* handle) {
-  handle->flags &= ~UV_HANDLE_READING;
-  DECREASE_ACTIVE_COUNT(handle->loop, handle);
-
-  uv__pipe_interrupt_read(handle);
-}
-
-
-/* Cleans up uv_pipe_t (server or connection) and all resources associated with
- * it. */
-void uv_pipe_cleanup(uv_loop_t* loop, uv_pipe_t* handle) {
-  int i;
-  HANDLE pipeHandle;
-
-  uv__pipe_interrupt_read(handle);
-
-  if (handle->name) {
-    uv__free(handle->name);
-    handle->name = NULL;
-  }
-
-  if (handle->flags & UV_HANDLE_PIPESERVER) {
-    for (i = 0; i < handle->pipe.serv.pending_instances; i++) {
-      pipeHandle = handle->pipe.serv.accept_reqs[i].pipeHandle;
-      if (pipeHandle != INVALID_HANDLE_VALUE) {
-        CloseHandle(pipeHandle);
-        handle->pipe.serv.accept_reqs[i].pipeHandle = INVALID_HANDLE_VALUE;
-      }
-    }
-    handle->handle = INVALID_HANDLE_VALUE;
-  }
-
-  if (handle->flags & UV_HANDLE_CONNECTION) {
-    handle->flags &= ~UV_HANDLE_WRITABLE;
-    eof_timer_destroy(handle);
-  }
-
-  if ((handle->flags & UV_HANDLE_CONNECTION)
-      && handle->handle != INVALID_HANDLE_VALUE)
-    close_pipe(handle);
-}
-
-
-void uv_pipe_close(uv_loop_t* loop, uv_pipe_t* handle) {
-  if (handle->flags & UV_HANDLE_READING) {
-    handle->flags &= ~UV_HANDLE_READING;
-    DECREASE_ACTIVE_COUNT(loop, handle);
-  }
-
-  if (handle->flags & UV_HANDLE_LISTENING) {
-    handle->flags &= ~UV_HANDLE_LISTENING;
-    DECREASE_ACTIVE_COUNT(loop, handle);
-  }
-
-  uv_pipe_cleanup(loop, handle);
-
-  if (handle->reqs_pending == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-
-  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-  uv__handle_closing(handle);
-}
-
-
-static void uv_pipe_queue_accept(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_pipe_accept_t* req, BOOL firstInstance) {
-  assert(handle->flags & UV_HANDLE_LISTENING);
-
-  if (!firstInstance) {
-    assert(req->pipeHandle == INVALID_HANDLE_VALUE);
-
-    req->pipeHandle = CreateNamedPipeW(handle->name,
-        PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | WRITE_DAC,
-        PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
-        PIPE_UNLIMITED_INSTANCES, 65536, 65536, 0, NULL);
-
-    if (req->pipeHandle == INVALID_HANDLE_VALUE) {
-      SET_REQ_ERROR(req, GetLastError());
-      uv_insert_pending_req(loop, (uv_req_t*) req);
-      handle->reqs_pending++;
-      return;
-    }
-
-    if (uv_set_pipe_handle(loop, handle, req->pipeHandle, -1, 0)) {
-      CloseHandle(req->pipeHandle);
-      req->pipeHandle = INVALID_HANDLE_VALUE;
-      SET_REQ_ERROR(req, GetLastError());
-      uv_insert_pending_req(loop, (uv_req_t*) req);
-      handle->reqs_pending++;
-      return;
-    }
-  }
-
-  assert(req->pipeHandle != INVALID_HANDLE_VALUE);
-
-  /* Prepare the overlapped structure. */
-  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
-
-  if (!ConnectNamedPipe(req->pipeHandle, &req->u.io.overlapped) &&
-      GetLastError() != ERROR_IO_PENDING) {
-    if (GetLastError() == ERROR_PIPE_CONNECTED) {
-      SET_REQ_SUCCESS(req);
-    } else {
-      CloseHandle(req->pipeHandle);
-      req->pipeHandle = INVALID_HANDLE_VALUE;
-      /* Make this req pending reporting an error. */
-      SET_REQ_ERROR(req, GetLastError());
-    }
-    uv_insert_pending_req(loop, (uv_req_t*) req);
-    handle->reqs_pending++;
-    return;
-  }
-
-  /* Wait for completion via IOCP */
-  handle->reqs_pending++;
-}
-
-
-int uv_pipe_accept(uv_pipe_t* server, uv_stream_t* client) {
-  uv_loop_t* loop = server->loop;
-  uv_pipe_t* pipe_client;
-  uv_pipe_accept_t* req;
-  QUEUE* q;
-  uv__ipc_xfer_queue_item_t* item;
-  int err;
-
-  if (server->ipc) {
-    if (QUEUE_EMPTY(&server->pipe.conn.ipc_xfer_queue)) {
-      /* No valid pending sockets. */
-      return WSAEWOULDBLOCK;
-    }
-
-    q = QUEUE_HEAD(&server->pipe.conn.ipc_xfer_queue);
-    QUEUE_REMOVE(q);
-    server->pipe.conn.ipc_xfer_queue_length--;
-    item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member);
-
-    err = uv__tcp_xfer_import(
-        (uv_tcp_t*) client, item->xfer_type, &item->xfer_info);
-    if (err != 0)
-      return err;
-
-    uv__free(item);
-
-  } else {
-    pipe_client = (uv_pipe_t*)client;
-
-    /* Find a connection instance that has been connected, but not yet
-     * accepted. */
-    req = server->pipe.serv.pending_accepts;
-
-    if (!req) {
-      /* No valid connections found, so we error out. */
-      return WSAEWOULDBLOCK;
-    }
-
-    /* Initialize the client handle and copy the pipeHandle to the client */
-    uv_pipe_connection_init(pipe_client);
-    pipe_client->handle = req->pipeHandle;
-    pipe_client->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-
-    /* Prepare the req to pick up a new connection */
-    server->pipe.serv.pending_accepts = req->next_pending;
-    req->next_pending = NULL;
-    req->pipeHandle = INVALID_HANDLE_VALUE;
-
-    if (!(server->flags & UV_HANDLE_CLOSING)) {
-      uv_pipe_queue_accept(loop, server, req, FALSE);
-    }
-  }
-
-  return 0;
-}
-
-
-/* Starts listening for connections for the given pipe. */
-int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  int i;
-
-  if (handle->flags & UV_HANDLE_LISTENING) {
-    handle->stream.serv.connection_cb = cb;
-  }
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    return WSAEINVAL;
-  }
-
-  if (handle->flags & UV_HANDLE_READING) {
-    return WSAEISCONN;
-  }
-
-  if (!(handle->flags & UV_HANDLE_PIPESERVER)) {
-    return ERROR_NOT_SUPPORTED;
-  }
-
-  handle->flags |= UV_HANDLE_LISTENING;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-  handle->stream.serv.connection_cb = cb;
-
-  /* First pipe handle should have already been created in uv_pipe_bind */
-  assert(handle->pipe.serv.accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE);
-
-  for (i = 0; i < handle->pipe.serv.pending_instances; i++) {
-    uv_pipe_queue_accept(loop, handle, &handle->pipe.serv.accept_reqs[i], i == 0);
-  }
-
-  return 0;
-}
-
-
-static DWORD WINAPI uv_pipe_zero_readfile_thread_proc(void* arg) {
-  uv_read_t* req = (uv_read_t*) arg;
-  uv_pipe_t* handle = (uv_pipe_t*) req->data;
-  uv_loop_t* loop = handle->loop;
-  volatile HANDLE* thread_ptr = &handle->pipe.conn.readfile_thread_handle;
-  CRITICAL_SECTION* lock = &handle->pipe.conn.readfile_thread_lock;
-  HANDLE thread;
-  DWORD bytes;
-  DWORD err;
-
-  assert(req->type == UV_READ);
-  assert(handle->type == UV_NAMED_PIPE);
-
-  err = 0;
-
-  /* Create a handle to the current thread. */
-  if (!DuplicateHandle(GetCurrentProcess(),
-                       GetCurrentThread(),
-                       GetCurrentProcess(),
-                       &thread,
-                       0,
-                       FALSE,
-                       DUPLICATE_SAME_ACCESS)) {
-    err = GetLastError();
-    goto out1;
-  }
-
-  /* The lock needs to be held when thread handle is modified. */
-  EnterCriticalSection(lock);
-  if (*thread_ptr == INVALID_HANDLE_VALUE) {
-    /* uv__pipe_interrupt_read() cancelled reading before we got here. */
-    err = ERROR_OPERATION_ABORTED;
-  } else {
-    /* Let main thread know which worker thread is doing the blocking read. */
-    assert(*thread_ptr == NULL);
-    *thread_ptr = thread;
-  }
-  LeaveCriticalSection(lock);
-
-  if (err)
-    goto out2;
-
-  /* Block the thread until data is available on the pipe, or the read is
-   * cancelled. */
-  if (!ReadFile(handle->handle, &uv_zero_, 0, &bytes, NULL))
-    err = GetLastError();
-
-  /* Let the main thread know the worker is past the point of blocking. */
-  assert(thread == *thread_ptr);
-  *thread_ptr = INVALID_HANDLE_VALUE;
-
-  /* Briefly acquire the mutex. Since the main thread holds the lock while it
-   * is spinning trying to cancel this thread's I/O, we will block here until
-   * it stops doing that. */
-  EnterCriticalSection(lock);
-  LeaveCriticalSection(lock);
-
-out2:
-  /* Close the handle to the current thread. */
-  CloseHandle(thread);
-
-out1:
-  /* Set request status and post a completion record to the IOCP. */
-  if (err)
-    SET_REQ_ERROR(req, err);
-  else
-    SET_REQ_SUCCESS(req);
-  POST_COMPLETION_FOR_REQ(loop, req);
-
-  return 0;
-}
-
-
-static DWORD WINAPI uv_pipe_writefile_thread_proc(void* parameter) {
-  int result;
-  DWORD bytes;
-  uv_write_t* req = (uv_write_t*) parameter;
-  uv_pipe_t* handle = (uv_pipe_t*) req->handle;
-  uv_loop_t* loop = handle->loop;
-
-  assert(req != NULL);
-  assert(req->type == UV_WRITE);
-  assert(handle->type == UV_NAMED_PIPE);
-  assert(req->write_buffer.base);
-
-  result = WriteFile(handle->handle,
-                     req->write_buffer.base,
-                     req->write_buffer.len,
-                     &bytes,
-                     NULL);
-
-  if (!result) {
-    SET_REQ_ERROR(req, GetLastError());
-  }
-
-  POST_COMPLETION_FOR_REQ(loop, req);
-  return 0;
-}
-
-
-static void CALLBACK post_completion_read_wait(void* context, BOOLEAN timed_out) {
-  uv_read_t* req;
-  uv_tcp_t* handle;
-
-  req = (uv_read_t*) context;
-  assert(req != NULL);
-  handle = (uv_tcp_t*)req->data;
-  assert(handle != NULL);
-  assert(!timed_out);
-
-  if (!PostQueuedCompletionStatus(handle->loop->iocp,
-                                  req->u.io.overlapped.InternalHigh,
-                                  0,
-                                  &req->u.io.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
-}
-
-
-static void CALLBACK post_completion_write_wait(void* context, BOOLEAN timed_out) {
-  uv_write_t* req;
-  uv_tcp_t* handle;
-
-  req = (uv_write_t*) context;
-  assert(req != NULL);
-  handle = (uv_tcp_t*)req->handle;
-  assert(handle != NULL);
-  assert(!timed_out);
-
-  if (!PostQueuedCompletionStatus(handle->loop->iocp,
-                                  req->u.io.overlapped.InternalHigh,
-                                  0,
-                                  &req->u.io.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
-}
-
-
-static void uv_pipe_queue_read(uv_loop_t* loop, uv_pipe_t* handle) {
-  uv_read_t* req;
-  int result;
-
-  assert(handle->flags & UV_HANDLE_READING);
-  assert(!(handle->flags & UV_HANDLE_READ_PENDING));
-
-  assert(handle->handle != INVALID_HANDLE_VALUE);
-
-  req = &handle->read_req;
-
-  if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) {
-    handle->pipe.conn.readfile_thread_handle = NULL; /* Reset cancellation. */
-    if (!QueueUserWorkItem(&uv_pipe_zero_readfile_thread_proc,
-                           req,
-                           WT_EXECUTELONGFUNCTION)) {
-      /* Make this req pending reporting an error. */
-      SET_REQ_ERROR(req, GetLastError());
-      goto error;
-    }
-  } else {
-    memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-      req->u.io.overlapped.hEvent = (HANDLE) ((uintptr_t) req->event_handle | 1);
-    }
-
-    /* Do 0-read */
-    result = ReadFile(handle->handle,
-                      &uv_zero_,
-                      0,
-                      NULL,
-                      &req->u.io.overlapped);
-
-    if (!result && GetLastError() != ERROR_IO_PENDING) {
-      /* Make this req pending reporting an error. */
-      SET_REQ_ERROR(req, GetLastError());
-      goto error;
-    }
-
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-      if (!req->event_handle) {
-        req->event_handle = CreateEvent(NULL, 0, 0, NULL);
-        if (!req->event_handle) {
-          uv_fatal_error(GetLastError(), "CreateEvent");
-        }
-      }
-      if (req->wait_handle == INVALID_HANDLE_VALUE) {
-        if (!RegisterWaitForSingleObject(&req->wait_handle,
-            req->u.io.overlapped.hEvent, post_completion_read_wait, (void*) req,
-            INFINITE, WT_EXECUTEINWAITTHREAD)) {
-          SET_REQ_ERROR(req, GetLastError());
-          goto error;
-        }
-      }
-    }
-  }
-
-  /* Start the eof timer if there is one */
-  eof_timer_start(handle);
-  handle->flags |= UV_HANDLE_READ_PENDING;
-  handle->reqs_pending++;
-  return;
-
-error:
-  uv_insert_pending_req(loop, (uv_req_t*)req);
-  handle->flags |= UV_HANDLE_READ_PENDING;
-  handle->reqs_pending++;
-}
-
-
-int uv_pipe_read_start(uv_pipe_t* handle,
-                       uv_alloc_cb alloc_cb,
-                       uv_read_cb read_cb) {
-  uv_loop_t* loop = handle->loop;
-
-  handle->flags |= UV_HANDLE_READING;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-  handle->read_cb = read_cb;
-  handle->alloc_cb = alloc_cb;
-
-  /* If reading was stopped and then started again, there could still be a read
-   * request pending. */
-  if (!(handle->flags & UV_HANDLE_READ_PENDING))
-    uv_pipe_queue_read(loop, handle);
-
-  return 0;
-}
-
-
-static void uv_insert_non_overlapped_write_req(uv_pipe_t* handle,
-    uv_write_t* req) {
-  req->next_req = NULL;
-  if (handle->pipe.conn.non_overlapped_writes_tail) {
-    req->next_req =
-      handle->pipe.conn.non_overlapped_writes_tail->next_req;
-    handle->pipe.conn.non_overlapped_writes_tail->next_req = (uv_req_t*)req;
-    handle->pipe.conn.non_overlapped_writes_tail = req;
-  } else {
-    req->next_req = (uv_req_t*)req;
-    handle->pipe.conn.non_overlapped_writes_tail = req;
-  }
-}
-
-
-static uv_write_t* uv_remove_non_overlapped_write_req(uv_pipe_t* handle) {
-  uv_write_t* req;
-
-  if (handle->pipe.conn.non_overlapped_writes_tail) {
-    req = (uv_write_t*)handle->pipe.conn.non_overlapped_writes_tail->next_req;
-
-    if (req == handle->pipe.conn.non_overlapped_writes_tail) {
-      handle->pipe.conn.non_overlapped_writes_tail = NULL;
-    } else {
-      handle->pipe.conn.non_overlapped_writes_tail->next_req =
-        req->next_req;
-    }
-
-    return req;
-  } else {
-    /* queue empty */
-    return NULL;
-  }
-}
-
-
-static void uv_queue_non_overlapped_write(uv_pipe_t* handle) {
-  uv_write_t* req = uv_remove_non_overlapped_write_req(handle);
-  if (req) {
-    if (!QueueUserWorkItem(&uv_pipe_writefile_thread_proc,
-                           req,
-                           WT_EXECUTELONGFUNCTION)) {
-      uv_fatal_error(GetLastError(), "QueueUserWorkItem");
-    }
-  }
-}
-
-
-static int uv__build_coalesced_write_req(uv_write_t* user_req,
-                                         const uv_buf_t bufs[],
-                                         size_t nbufs,
-                                         uv_write_t** req_out,
-                                         uv_buf_t* write_buf_out) {
-  /* Pack into a single heap-allocated buffer:
-   *   (a) a uv_write_t structure where libuv stores the actual state.
-   *   (b) a pointer to the original uv_write_t.
-   *   (c) data from all `bufs` entries.
-   */
-  char* heap_buffer;
-  size_t heap_buffer_length, heap_buffer_offset;
-  uv__coalesced_write_t* coalesced_write_req; /* (a) + (b) */
-  char* data_start;                           /* (c) */
-  size_t data_length;
-  unsigned int i;
-
-  /* Compute combined size of all combined buffers from `bufs`. */
-  data_length = 0;
-  for (i = 0; i < nbufs; i++)
-    data_length += bufs[i].len;
-
-  /* The total combined size of data buffers should not exceed UINT32_MAX,
-   * because WriteFile() won't accept buffers larger than that. */
-  if (data_length > UINT32_MAX)
-    return WSAENOBUFS; /* Maps to UV_ENOBUFS. */
-
-  /* Compute heap buffer size. */
-  heap_buffer_length = sizeof *coalesced_write_req + /* (a) + (b) */
-                       data_length;                  /* (c) */
-
-  /* Allocate buffer. */
-  heap_buffer = (char*)uv__malloc(heap_buffer_length);
-  if (heap_buffer == NULL)
-    return ERROR_NOT_ENOUGH_MEMORY; /* Maps to UV_ENOMEM. */
-
-  /* Copy uv_write_t information to the buffer. */
-  coalesced_write_req = (uv__coalesced_write_t*) heap_buffer;
-  coalesced_write_req->req = *user_req; /* copy (a) */
-  coalesced_write_req->req.coalesced = 1;
-  coalesced_write_req->user_req = user_req;         /* copy (b) */
-  heap_buffer_offset = sizeof *coalesced_write_req; /* offset (a) + (b) */
-
-  /* Copy data buffers to the heap buffer. */
-  data_start = &heap_buffer[heap_buffer_offset];
-  for (i = 0; i < nbufs; i++) {
-    memcpy(&heap_buffer[heap_buffer_offset],
-           bufs[i].base,
-           bufs[i].len);               /* copy (c) */
-    heap_buffer_offset += bufs[i].len; /* offset (c) */
-  }
-  assert(heap_buffer_offset == heap_buffer_length);
-
-  /* Set out arguments and return. */
-  *req_out = &coalesced_write_req->req;
-  *write_buf_out = uv_buf_init(data_start, (unsigned int) data_length);
-  return 0;
-}
-
-
-static int uv__pipe_write_data(uv_loop_t* loop,
-                               uv_write_t* req,
-                               uv_pipe_t* handle,
-                               const uv_buf_t bufs[],
-                               size_t nbufs,
-                               uv_write_cb cb,
-                               int copy_always) {
-  int err;
-  int result;
-  uv_buf_t write_buf;
-
-  assert(handle->handle != INVALID_HANDLE_VALUE);
-
-  UV_REQ_INIT(req, UV_WRITE);
-  req->handle = (uv_stream_t*) handle;
-  req->send_handle = NULL;
-  req->cb = cb;
-  /* Private fields. */
-  req->coalesced = 0;
-  req->event_handle = NULL;
-  req->wait_handle = INVALID_HANDLE_VALUE;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-  req->write_buffer = uv_null_buf_;
-
-  if (nbufs == 0) {
-    /* Write empty buffer. */
-    write_buf = uv_null_buf_;
-  } else if (nbufs == 1 && !copy_always) {
-    /* Write directly from bufs[0]. */
-    write_buf = bufs[0];
-  } else {
-    /* Coalesce all `bufs` into one big buffer. This also creates a new
-     * write-request structure that replaces the old one. */
-    err = uv__build_coalesced_write_req(req, bufs, nbufs, &req, &write_buf);
-    if (err != 0)
-      return err;
-  }
-
-  if ((handle->flags &
-      (UV_HANDLE_BLOCKING_WRITES | UV_HANDLE_NON_OVERLAPPED_PIPE)) ==
-      (UV_HANDLE_BLOCKING_WRITES | UV_HANDLE_NON_OVERLAPPED_PIPE)) {
-    DWORD bytes;
-    result =
-        WriteFile(handle->handle, write_buf.base, write_buf.len, &bytes, NULL);
-
-    if (!result) {
-      err = GetLastError();
-      return err;
-    } else {
-      /* Request completed immediately. */
-      req->u.io.queued_bytes = 0;
-    }
-
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    handle->reqs_pending++;
-    handle->stream.conn.write_reqs_pending++;
-    POST_COMPLETION_FOR_REQ(loop, req);
-    return 0;
-  } else if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) {
-    req->write_buffer = write_buf;
-    uv_insert_non_overlapped_write_req(handle, req);
-    if (handle->stream.conn.write_reqs_pending == 0) {
-      uv_queue_non_overlapped_write(handle);
-    }
-
-    /* Request queued by the kernel. */
-    req->u.io.queued_bytes = write_buf.len;
-    handle->write_queue_size += req->u.io.queued_bytes;
-  } else if (handle->flags & UV_HANDLE_BLOCKING_WRITES) {
-    /* Using overlapped IO, but wait for completion before returning */
-    req->u.io.overlapped.hEvent = CreateEvent(NULL, 1, 0, NULL);
-    if (!req->u.io.overlapped.hEvent) {
-      uv_fatal_error(GetLastError(), "CreateEvent");
-    }
-
-    result = WriteFile(handle->handle,
-                       write_buf.base,
-                       write_buf.len,
-                       NULL,
-                       &req->u.io.overlapped);
-
-    if (!result && GetLastError() != ERROR_IO_PENDING) {
-      err = GetLastError();
-      CloseHandle(req->u.io.overlapped.hEvent);
-      return err;
-    }
-
-    if (result) {
-      /* Request completed immediately. */
-      req->u.io.queued_bytes = 0;
-    } else {
-      /* Request queued by the kernel. */
-      req->u.io.queued_bytes = write_buf.len;
-      handle->write_queue_size += req->u.io.queued_bytes;
-      if (WaitForSingleObject(req->u.io.overlapped.hEvent, INFINITE) !=
-          WAIT_OBJECT_0) {
-        err = GetLastError();
-        CloseHandle(req->u.io.overlapped.hEvent);
-        return err;
-      }
-    }
-    CloseHandle(req->u.io.overlapped.hEvent);
-
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    handle->reqs_pending++;
-    handle->stream.conn.write_reqs_pending++;
-    return 0;
-  } else {
-    result = WriteFile(handle->handle,
-                       write_buf.base,
-                       write_buf.len,
-                       NULL,
-                       &req->u.io.overlapped);
-
-    if (!result && GetLastError() != ERROR_IO_PENDING) {
-      return GetLastError();
-    }
-
-    if (result) {
-      /* Request completed immediately. */
-      req->u.io.queued_bytes = 0;
-    } else {
-      /* Request queued by the kernel. */
-      req->u.io.queued_bytes = write_buf.len;
-      handle->write_queue_size += req->u.io.queued_bytes;
-    }
-
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-      req->event_handle = CreateEvent(NULL, 0, 0, NULL);
-      if (!req->event_handle) {
-        uv_fatal_error(GetLastError(), "CreateEvent");
-      }
-      if (!RegisterWaitForSingleObject(&req->wait_handle,
-          req->u.io.overlapped.hEvent, post_completion_write_wait, (void*) req,
-          INFINITE, WT_EXECUTEINWAITTHREAD)) {
-        return GetLastError();
-      }
-    }
-  }
-
-  REGISTER_HANDLE_REQ(loop, handle, req);
-  handle->reqs_pending++;
-  handle->stream.conn.write_reqs_pending++;
-
-  return 0;
-}
-
-
-static DWORD uv__pipe_get_ipc_remote_pid(uv_pipe_t* handle) {
-  DWORD* pid = &handle->pipe.conn.ipc_remote_pid;
-
-  /* If the both ends of the IPC pipe are owned by the same process,
-   * the remote end pid may not yet be set. If so, do it here.
-   * TODO: this is weird; it'd probably better to use a handshake. */
-  if (*pid == 0)
-    *pid = GetCurrentProcessId();
-
-  return *pid;
-}
-
-
-int uv__pipe_write_ipc(uv_loop_t* loop,
-                       uv_write_t* req,
-                       uv_pipe_t* handle,
-                       const uv_buf_t data_bufs[],
-                       size_t data_buf_count,
-                       uv_stream_t* send_handle,
-                       uv_write_cb cb) {
-  uv_buf_t stack_bufs[6];
-  uv_buf_t* bufs;
-  size_t buf_count, buf_index;
-  uv__ipc_frame_header_t frame_header;
-  uv__ipc_socket_xfer_type_t xfer_type = UV__IPC_SOCKET_XFER_NONE;
-  uv__ipc_socket_xfer_info_t xfer_info;
-  uint64_t data_length;
-  size_t i;
-  int err;
-
-  /* Compute the combined size of data buffers. */
-  data_length = 0;
-  for (i = 0; i < data_buf_count; i++)
-    data_length += data_bufs[i].len;
-  if (data_length > UINT32_MAX)
-    return WSAENOBUFS; /* Maps to UV_ENOBUFS. */
-
-  /* Prepare the frame's socket xfer payload. */
-  if (send_handle != NULL) {
-    uv_tcp_t* send_tcp_handle = (uv_tcp_t*) send_handle;
-
-    /* Verify that `send_handle` it is indeed a tcp handle. */
-    if (send_tcp_handle->type != UV_TCP)
-      return ERROR_NOT_SUPPORTED;
-
-    /* Export the tcp handle. */
-    err = uv__tcp_xfer_export(send_tcp_handle,
-                              uv__pipe_get_ipc_remote_pid(handle),
-                              &xfer_type,
-                              &xfer_info);
-    if (err != 0)
-      return err;
-  }
-
-  /* Compute the number of uv_buf_t's required. */
-  buf_count = 1 + data_buf_count; /* Frame header and data buffers. */
-  if (send_handle != NULL)
-    buf_count += 1; /* One extra for the socket xfer information. */
-
-  /* Use the on-stack buffer array if it is big enough; otherwise allocate
-   * space for it on the heap. */
-  if (buf_count < ARRAY_SIZE(stack_bufs)) {
-    /* Use on-stack buffer array. */
-    bufs = stack_bufs;
-  } else {
-    /* Use heap-allocated buffer array. */
-    bufs = (uv_buf_t*)uv__calloc(buf_count, sizeof(uv_buf_t));
-    if (bufs == NULL)
-      return ERROR_NOT_ENOUGH_MEMORY; /* Maps to UV_ENOMEM. */
-  }
-  buf_index = 0;
-
-  /* Initialize frame header and add it to the buffers list. */
-  memset(&frame_header, 0, sizeof frame_header);
-  bufs[buf_index++] = uv_buf_init((char*) &frame_header, sizeof frame_header);
-
-  if (send_handle != NULL) {
-    /* Add frame header flags. */
-    switch (xfer_type) {
-      case UV__IPC_SOCKET_XFER_TCP_CONNECTION:
-        frame_header.flags |= UV__IPC_FRAME_HAS_SOCKET_XFER |
-                              UV__IPC_FRAME_XFER_IS_TCP_CONNECTION;
-        break;
-      case UV__IPC_SOCKET_XFER_TCP_SERVER:
-        frame_header.flags |= UV__IPC_FRAME_HAS_SOCKET_XFER;
-        break;
-      default:
-        assert(0);  /* Unreachable. */
-    }
-    /* Add xfer info buffer. */
-    bufs[buf_index++] = uv_buf_init((char*) &xfer_info, sizeof xfer_info);
-  }
-
-  if (data_length > 0) {
-    /* Update frame header. */
-    frame_header.flags |= UV__IPC_FRAME_HAS_DATA;
-    frame_header.data_length = (uint32_t) data_length;
-    /* Add data buffers to buffers list. */
-    for (i = 0; i < data_buf_count; i++)
-      bufs[buf_index++] = data_bufs[i];
-  }
-
-  /* Write buffers. We set the `always_copy` flag, so it is not a problem that
-   * some of the written data lives on the stack. */
-  err = uv__pipe_write_data(loop, req, handle, bufs, buf_count, cb, 1);
-
-  /* If we had to heap-allocate the bufs array, free it now. */
-  if (bufs != stack_bufs) {
-    uv__free(bufs);
-  }
-
-  return err;
-}
-
-
-int uv__pipe_write(uv_loop_t* loop,
-                   uv_write_t* req,
-                   uv_pipe_t* handle,
-                   const uv_buf_t bufs[],
-                   size_t nbufs,
-                   uv_stream_t* send_handle,
-                   uv_write_cb cb) {
-  if (handle->ipc) {
-    /* IPC pipe write: use framing protocol. */
-    return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb);
-  } else {
-    /* Non-IPC pipe write: put data on the wire directly. */
-    assert(send_handle == NULL);
-    return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0);
-  }
-}
-
-
-static void uv_pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_buf_t buf) {
-  /* If there is an eof timer running, we don't need it any more, so discard
-   * it. */
-  eof_timer_destroy(handle);
-
-  handle->flags &= ~UV_HANDLE_READABLE;
-  uv_read_stop((uv_stream_t*) handle);
-
-  handle->read_cb((uv_stream_t*) handle, UV_EOF, &buf);
-}
-
-
-static void uv_pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error,
-    uv_buf_t buf) {
-  /* If there is an eof timer running, we don't need it any more, so discard
-   * it. */
-  eof_timer_destroy(handle);
-
-  uv_read_stop((uv_stream_t*) handle);
-
-  handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), &buf);
-}
-
-
-static void uv_pipe_read_error_or_eof(uv_loop_t* loop, uv_pipe_t* handle,
-    int error, uv_buf_t buf) {
-  if (error == ERROR_BROKEN_PIPE) {
-    uv_pipe_read_eof(loop, handle, buf);
-  } else {
-    uv_pipe_read_error(loop, handle, error, buf);
-  }
-}
-
-
-static void uv__pipe_queue_ipc_xfer_info(
-    uv_pipe_t* handle,
-    uv__ipc_socket_xfer_type_t xfer_type,
-    uv__ipc_socket_xfer_info_t* xfer_info) {
-  uv__ipc_xfer_queue_item_t* item;
-
-  item = (uv__ipc_xfer_queue_item_t*) uv__malloc(sizeof(*item));
-  if (item == NULL)
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-
-  item->xfer_type = xfer_type;
-  item->xfer_info = *xfer_info;
-
-  QUEUE_INSERT_TAIL(&handle->pipe.conn.ipc_xfer_queue, &item->member);
-  handle->pipe.conn.ipc_xfer_queue_length++;
-}
-
-
-/* Read an exact number of bytes from a pipe. If an error or end-of-file is
- * encountered before the requested number of bytes are read, an error is
- * returned. */
-static int uv__pipe_read_exactly(HANDLE h, void* buffer, DWORD count) {
-  DWORD bytes_read, bytes_read_now;
-
-  bytes_read = 0;
-  while (bytes_read < count) {
-    if (!ReadFile(h,
-                  (char*) buffer + bytes_read,
-                  count - bytes_read,
-                  &bytes_read_now,
-                  NULL)) {
-      return GetLastError();
-    }
-
-    bytes_read += bytes_read_now;
-  }
-
-  assert(bytes_read == count);
-  return 0;
-}
-
-
-static DWORD uv__pipe_read_data(uv_loop_t* loop,
-                                uv_pipe_t* handle,
-                                DWORD suggested_bytes,
-                                DWORD max_bytes) {
-  DWORD bytes_read;
-  uv_buf_t buf;
-
-  /* Ask the user for a buffer to read data into. */
-  buf = uv_buf_init(NULL, 0);
-  handle->alloc_cb((uv_handle_t*) handle, suggested_bytes, &buf);
-  if (buf.base == NULL || buf.len == 0) {
-    handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
-    return 0; /* Break out of read loop. */
-  }
-
-  /* Ensure we read at most the smaller of:
-   *   (a) the length of the user-allocated buffer.
-   *   (b) the maximum data length as specified by the `max_bytes` argument.
-   */
-  if (max_bytes > buf.len)
-    max_bytes = buf.len;
-
-  /* Read into the user buffer. */
-  if (!ReadFile(handle->handle, buf.base, max_bytes, &bytes_read, NULL)) {
-    uv_pipe_read_error_or_eof(loop, handle, GetLastError(), buf);
-    return 0; /* Break out of read loop. */
-  }
-
-  /* Call the read callback. */
-  handle->read_cb((uv_stream_t*) handle, bytes_read, &buf);
-
-  return bytes_read;
-}
-
-
-static DWORD uv__pipe_read_ipc(uv_loop_t* loop, uv_pipe_t* handle) {
-  uint32_t* data_remaining = &handle->pipe.conn.ipc_data_frame.payload_remaining;
-  int err;
-
-  if (*data_remaining > 0) {
-    /* Read frame data payload. */
-    DWORD bytes_read =
-        uv__pipe_read_data(loop, handle, *data_remaining, *data_remaining);
-    *data_remaining -= bytes_read;
-    return bytes_read;
-
-  } else {
-    /* Start of a new IPC frame. */
-    uv__ipc_frame_header_t frame_header;
-    uint32_t xfer_flags;
-    uv__ipc_socket_xfer_type_t xfer_type;
-    uv__ipc_socket_xfer_info_t xfer_info;
-
-    /* Read the IPC frame header. */
-    err = uv__pipe_read_exactly(
-        handle->handle, &frame_header, sizeof frame_header);
-    if (err)
-      goto error;
-
-    /* Validate that flags are valid. */
-    if ((frame_header.flags & ~UV__IPC_FRAME_VALID_FLAGS) != 0)
-      goto invalid;
-    /* Validate that reserved2 is zero. */
-    if (frame_header.reserved2 != 0)
-      goto invalid;
-
-    /* Parse xfer flags. */
-    xfer_flags = frame_header.flags & UV__IPC_FRAME_XFER_FLAGS;
-    if (xfer_flags & UV__IPC_FRAME_HAS_SOCKET_XFER) {
-      /* Socket coming -- determine the type. */
-      xfer_type = xfer_flags & UV__IPC_FRAME_XFER_IS_TCP_CONNECTION
-                      ? UV__IPC_SOCKET_XFER_TCP_CONNECTION
-                      : UV__IPC_SOCKET_XFER_TCP_SERVER;
-    } else if (xfer_flags == 0) {
-      /* No socket. */
-      xfer_type = UV__IPC_SOCKET_XFER_NONE;
-    } else {
-      /* Invalid flags. */
-      goto invalid;
-    }
-
-    /* Parse data frame information. */
-    if (frame_header.flags & UV__IPC_FRAME_HAS_DATA) {
-      *data_remaining = frame_header.data_length;
-    } else if (frame_header.data_length != 0) {
-      /* Data length greater than zero but data flag not set -- invalid. */
-      goto invalid;
-    }
-
-    /* If no socket xfer info follows, return here. Data will be read in a
-     * subsequent invocation of uv__pipe_read_ipc(). */
-    if (xfer_type == UV__IPC_SOCKET_XFER_NONE)
-      return sizeof frame_header; /* Number of bytes read. */
-
-    /* Read transferred socket information. */
-    err = uv__pipe_read_exactly(handle->handle, &xfer_info, sizeof xfer_info);
-    if (err)
-      goto error;
-
-    /* Store the pending socket info. */
-    uv__pipe_queue_ipc_xfer_info(handle, xfer_type, &xfer_info);
-
-    /* Return number of bytes read. */
-    return sizeof frame_header + sizeof xfer_info;
-  }
-
-invalid:
-  /* Invalid frame. */
-  err = WSAECONNABORTED; /* Maps to UV_ECONNABORTED. */
-
-error:
-  uv_pipe_read_error_or_eof(loop, handle, err, uv_null_buf_);
-  return 0; /* Break out of read loop. */
-}
-
-
-void uv_process_pipe_read_req(uv_loop_t* loop,
-                              uv_pipe_t* handle,
-                              uv_req_t* req) {
-  assert(handle->type == UV_NAMED_PIPE);
-
-  handle->flags &= ~(UV_HANDLE_READ_PENDING | UV_HANDLE_CANCELLATION_PENDING);
-  DECREASE_PENDING_REQ_COUNT(handle);
-  eof_timer_stop(handle);
-
-  /* At this point, we're done with bookkeeping. If the user has stopped
-   * reading the pipe in the meantime, there is nothing left to do, since there
-   * is no callback that we can call. */
-  if (!(handle->flags & UV_HANDLE_READING))
-    return;
-
-  if (!REQ_SUCCESS(req)) {
-    /* An error occurred doing the zero-read. */
-    DWORD err = GET_REQ_ERROR(req);
-
-    /* If the read was cancelled by uv__pipe_interrupt_read(), the request may
-     * indicate an ERROR_OPERATION_ABORTED error. This error isn't relevant to
-     * the user; we'll start a new zero-read at the end of this function. */
-    if (err != ERROR_OPERATION_ABORTED)
-      uv_pipe_read_error_or_eof(loop, handle, err, uv_null_buf_);
-
-  } else {
-    /* The zero-read completed without error, indicating there is data
-     * available in the kernel buffer. */
-    DWORD avail;
-
-    /* Get the number of bytes available. */
-    avail = 0;
-    if (!PeekNamedPipe(handle->handle, NULL, 0, NULL, &avail, NULL))
-      uv_pipe_read_error_or_eof(loop, handle, GetLastError(), uv_null_buf_);
-
-    /* Read until we've either read all the bytes available, or the 'reading'
-     * flag is cleared. */
-    while (avail > 0 && handle->flags & UV_HANDLE_READING) {
-      /* Depending on the type of pipe, read either IPC frames or raw data. */
-      DWORD bytes_read =
-          handle->ipc ? uv__pipe_read_ipc(loop, handle)
-                      : uv__pipe_read_data(loop, handle, avail, (DWORD) -1);
-
-      /* If no bytes were read, treat this as an indication that an error
-       * occurred, and break out of the read loop. */
-      if (bytes_read == 0)
-        break;
-
-      /* It is possible that more bytes were read than we thought were
-       * available. To prevent `avail` from underflowing, break out of the loop
-       * if this is the case. */
-      if (bytes_read > avail)
-        break;
-
-      /* Recompute the number of bytes available. */
-      avail -= bytes_read;
-    }
-  }
-
-  /* Start another zero-read request if necessary. */
-  if ((handle->flags & UV_HANDLE_READING) &&
-      !(handle->flags & UV_HANDLE_READ_PENDING)) {
-    uv_pipe_queue_read(loop, handle);
-  }
-}
-
-
-void uv_process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_write_t* req) {
-  int err;
-
-  assert(handle->type == UV_NAMED_PIPE);
-
-  assert(handle->write_queue_size >= req->u.io.queued_bytes);
-  handle->write_queue_size -= req->u.io.queued_bytes;
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-    if (req->wait_handle != INVALID_HANDLE_VALUE) {
-      UnregisterWait(req->wait_handle);
-      req->wait_handle = INVALID_HANDLE_VALUE;
-    }
-    if (req->event_handle) {
-      CloseHandle(req->event_handle);
-      req->event_handle = NULL;
-    }
-  }
-
-  err = GET_REQ_ERROR(req);
-
-  /* If this was a coalesced write, extract pointer to the user_provided
-   * uv_write_t structure so we can pass the expected pointer to the callback,
-   * then free the heap-allocated write req. */
-  if (req->coalesced) {
-    uv__coalesced_write_t* coalesced_write =
-        container_of(req, uv__coalesced_write_t, req);
-    req = coalesced_write->user_req;
-    uv__free(coalesced_write);
-  }
-  if (req->cb) {
-    req->cb(req, uv_translate_sys_error(err));
-  }
-
-  handle->stream.conn.write_reqs_pending--;
-
-  if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE &&
-      handle->pipe.conn.non_overlapped_writes_tail) {
-    assert(handle->stream.conn.write_reqs_pending > 0);
-    uv_queue_non_overlapped_write(handle);
-  }
-
-  if (handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_req_t* raw_req) {
-  uv_pipe_accept_t* req = (uv_pipe_accept_t*) raw_req;
-
-  assert(handle->type == UV_NAMED_PIPE);
-
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    /* The req->pipeHandle should be freed already in uv_pipe_cleanup(). */
-    assert(req->pipeHandle == INVALID_HANDLE_VALUE);
-    DECREASE_PENDING_REQ_COUNT(handle);
-    return;
-  }
-
-  if (REQ_SUCCESS(req)) {
-    assert(req->pipeHandle != INVALID_HANDLE_VALUE);
-    req->next_pending = handle->pipe.serv.pending_accepts;
-    handle->pipe.serv.pending_accepts = req;
-
-    if (handle->stream.serv.connection_cb) {
-      handle->stream.serv.connection_cb((uv_stream_t*)handle, 0);
-    }
-  } else {
-    if (req->pipeHandle != INVALID_HANDLE_VALUE) {
-      CloseHandle(req->pipeHandle);
-      req->pipeHandle = INVALID_HANDLE_VALUE;
-    }
-    if (!(handle->flags & UV_HANDLE_CLOSING)) {
-      uv_pipe_queue_accept(loop, handle, req, FALSE);
-    }
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_connect_t* req) {
-  int err;
-
-  assert(handle->type == UV_NAMED_PIPE);
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (req->cb) {
-    err = 0;
-    if (REQ_SUCCESS(req)) {
-      uv_pipe_connection_init(handle);
-    } else {
-      err = GET_REQ_ERROR(req);
-    }
-    req->cb(req, uv_translate_sys_error(err));
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
-    uv_shutdown_t* req) {
-  assert(handle->type == UV_NAMED_PIPE);
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (handle->flags & UV_HANDLE_READABLE) {
-    /* Initialize and optionally start the eof timer. Only do this if the pipe
-     * is readable and we haven't seen EOF come in ourselves. */
-    eof_timer_init(handle);
-
-    /* If reading start the timer right now. Otherwise uv_pipe_queue_read will
-     * start it. */
-    if (handle->flags & UV_HANDLE_READ_PENDING) {
-      eof_timer_start(handle);
-    }
-
-  } else {
-    /* This pipe is not readable. We can just close it to let the other end
-     * know that we're done writing. */
-    close_pipe(handle);
-  }
-
-  if (req->cb) {
-    req->cb(req, 0);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-static void eof_timer_init(uv_pipe_t* pipe) {
-  int r;
-
-  assert(pipe->pipe.conn.eof_timer == NULL);
-  assert(pipe->flags & UV_HANDLE_CONNECTION);
-
-  pipe->pipe.conn.eof_timer = (uv_timer_t*) uv__malloc(sizeof *pipe->pipe.conn.eof_timer);
-
-  r = uv_timer_init(pipe->loop, pipe->pipe.conn.eof_timer);
-  assert(r == 0); /* timers can't fail */
-  pipe->pipe.conn.eof_timer->data = pipe;
-  uv_unref((uv_handle_t*) pipe->pipe.conn.eof_timer);
-}
-
-
-static void eof_timer_start(uv_pipe_t* pipe) {
-  assert(pipe->flags & UV_HANDLE_CONNECTION);
-
-  if (pipe->pipe.conn.eof_timer != NULL) {
-    uv_timer_start(pipe->pipe.conn.eof_timer, eof_timer_cb, eof_timeout, 0);
-  }
-}
-
-
-static void eof_timer_stop(uv_pipe_t* pipe) {
-  assert(pipe->flags & UV_HANDLE_CONNECTION);
-
-  if (pipe->pipe.conn.eof_timer != NULL) {
-    uv_timer_stop(pipe->pipe.conn.eof_timer);
-  }
-}
-
-
-static void eof_timer_cb(uv_timer_t* timer) {
-  uv_pipe_t* pipe = (uv_pipe_t*) timer->data;
-  uv_loop_t* loop = timer->loop;
-
-  assert(pipe->type == UV_NAMED_PIPE);
-
-  /* This should always be true, since we start the timer only in
-   * uv_pipe_queue_read after successfully calling ReadFile, or in
-   * uv_process_pipe_shutdown_req if a read is pending, and we always
-   * immediately stop the timer in uv_process_pipe_read_req. */
-  assert(pipe->flags & UV_HANDLE_READ_PENDING);
-
-  /* If there are many packets coming off the iocp then the timer callback may
-   * be called before the read request is coming off the queue. Therefore we
-   * check here if the read request has completed but will be processed later.
-   */
-  if ((pipe->flags & UV_HANDLE_READ_PENDING) &&
-      HasOverlappedIoCompleted(&pipe->read_req.u.io.overlapped)) {
-    return;
-  }
-
-  /* Force both ends off the pipe. */
-  close_pipe(pipe);
-
-  /* Stop reading, so the pending read that is going to fail will not be
-   * reported to the user. */
-  uv_read_stop((uv_stream_t*) pipe);
-
-  /* Report the eof and update flags. This will get reported even if the user
-   * stopped reading in the meantime. TODO: is that okay? */
-  uv_pipe_read_eof(loop, pipe, uv_null_buf_);
-}
-
-
-static void eof_timer_destroy(uv_pipe_t* pipe) {
-  assert(pipe->flags & UV_HANDLE_CONNECTION);
-
-  if (pipe->pipe.conn.eof_timer) {
-    uv_close((uv_handle_t*) pipe->pipe.conn.eof_timer, eof_timer_close_cb);
-    pipe->pipe.conn.eof_timer = NULL;
-  }
-}
-
-
-static void eof_timer_close_cb(uv_handle_t* handle) {
-  assert(handle->type == UV_TIMER);
-  uv__free(handle);
-}
-
-
-int uv_pipe_open(uv_pipe_t* pipe, uv_file file) {
-  HANDLE os_handle = uv__get_osfhandle(file);
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-  FILE_ACCESS_INFORMATION access;
-  DWORD duplex_flags = 0;
-
-  if (os_handle == INVALID_HANDLE_VALUE)
-    return UV_EBADF;
-
-  uv__once_init();
-  /* In order to avoid closing a stdio file descriptor 0-2, duplicate the
-   * underlying OS handle and forget about the original fd.
-   * We could also opt to use the original OS handle and just never close it,
-   * but then there would be no reliable way to cancel pending read operations
-   * upon close.
-   */
-  if (file <= 2) {
-    if (!DuplicateHandle(INVALID_HANDLE_VALUE,
-                         os_handle,
-                         INVALID_HANDLE_VALUE,
-                         &os_handle,
-                         0,
-                         FALSE,
-                         DUPLICATE_SAME_ACCESS))
-      return uv_translate_sys_error(GetLastError());
-    file = -1;
-  }
-
-  /* Determine what kind of permissions we have on this handle.
-   * Cygwin opens the pipe in message mode, but we can support it,
-   * just query the access flags and set the stream flags accordingly.
-   */
-  nt_status = pNtQueryInformationFile(os_handle,
-                                      &io_status,
-                                      &access,
-                                      sizeof(access),
-                                      FileAccessInformation);
-  if (nt_status != STATUS_SUCCESS)
-    return UV_EINVAL;
-
-  if (pipe->ipc) {
-    if (!(access.AccessFlags & FILE_WRITE_DATA) ||
-        !(access.AccessFlags & FILE_READ_DATA)) {
-      return UV_EINVAL;
-    }
-  }
-
-  if (access.AccessFlags & FILE_WRITE_DATA)
-    duplex_flags |= UV_HANDLE_WRITABLE;
-  if (access.AccessFlags & FILE_READ_DATA)
-    duplex_flags |= UV_HANDLE_READABLE;
-
-  if (os_handle == INVALID_HANDLE_VALUE ||
-      uv_set_pipe_handle(pipe->loop,
-                         pipe,
-                         os_handle,
-                         file,
-                         duplex_flags) == -1) {
-    return UV_EINVAL;
-  }
-
-  uv_pipe_connection_init(pipe);
-
-  if (pipe->ipc) {
-    assert(!(pipe->flags & UV_HANDLE_NON_OVERLAPPED_PIPE));
-    pipe->pipe.conn.ipc_remote_pid = uv_os_getppid();
-    assert(pipe->pipe.conn.ipc_remote_pid != (DWORD) -1);
-  }
-  return 0;
-}
-
-
-static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) {
-  NTSTATUS nt_status;
-  IO_STATUS_BLOCK io_status;
-  FILE_NAME_INFORMATION tmp_name_info;
-  FILE_NAME_INFORMATION* name_info;
-  WCHAR* name_buf;
-  unsigned int addrlen;
-  unsigned int name_size;
-  unsigned int name_len;
-  int err;
-
-  uv__once_init();
-  name_info = NULL;
-
-  if (handle->handle == INVALID_HANDLE_VALUE) {
-    *size = 0;
-    return UV_EINVAL;
-  }
-
-  /* NtQueryInformationFile will block if another thread is performing a
-   * blocking operation on the queried handle. If the pipe handle is
-   * synchronous, there may be a worker thread currently calling ReadFile() on
-   * the pipe handle, which could cause a deadlock. To avoid this, interrupt
-   * the read. */
-  if (handle->flags & UV_HANDLE_CONNECTION &&
-      handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) {
-    uv__pipe_interrupt_read((uv_pipe_t*) handle); /* cast away const warning */
-  }
-
-  nt_status = pNtQueryInformationFile(handle->handle,
-                                      &io_status,
-                                      &tmp_name_info,
-                                      sizeof tmp_name_info,
-                                      FileNameInformation);
-  if (nt_status == STATUS_BUFFER_OVERFLOW) {
-    name_size = sizeof(*name_info) + tmp_name_info.FileNameLength;
-    name_info = (FILE_NAME_INFORMATION*)uv__malloc(name_size);
-    if (!name_info) {
-      *size = 0;
-      err = UV_ENOMEM;
-      goto cleanup;
-    }
-
-    nt_status = pNtQueryInformationFile(handle->handle,
-                                        &io_status,
-                                        name_info,
-                                        name_size,
-                                        FileNameInformation);
-  }
-
-  if (nt_status != STATUS_SUCCESS) {
-    *size = 0;
-    err = uv_translate_sys_error(pRtlNtStatusToDosError(nt_status));
-    goto error;
-  }
-
-  if (!name_info) {
-    /* the struct on stack was used */
-    name_buf = tmp_name_info.FileName;
-    name_len = tmp_name_info.FileNameLength;
-  } else {
-    name_buf = name_info->FileName;
-    name_len = name_info->FileNameLength;
-  }
-
-  if (name_len == 0) {
-    *size = 0;
-    err = 0;
-    goto error;
-  }
-
-  name_len /= sizeof(WCHAR);
-
-  /* check how much space we need */
-  addrlen = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                name_buf,
-                                name_len,
-                                NULL,
-                                0,
-                                NULL,
-                                NULL);
-  if (!addrlen) {
-    *size = 0;
-    err = uv_translate_sys_error(GetLastError());
-    goto error;
-  } else if (pipe_prefix_len + addrlen >= *size) {
-    /* "\\\\.\\pipe" + name */
-    *size = pipe_prefix_len + addrlen + 1;
-    err = UV_ENOBUFS;
-    goto error;
-  }
-
-  memcpy(buffer, pipe_prefix, pipe_prefix_len);
-  addrlen = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                name_buf,
-                                name_len,
-                                buffer+pipe_prefix_len,
-                                *size-pipe_prefix_len,
-                                NULL,
-                                NULL);
-  if (!addrlen) {
-    *size = 0;
-    err = uv_translate_sys_error(GetLastError());
-    goto error;
-  }
-
-  addrlen += pipe_prefix_len;
-  *size = addrlen;
-  buffer[addrlen] = '\0';
-
-  err = 0;
-
-error:
-  uv__free(name_info);
-
-cleanup:
-  return err;
-}
-
-
-int uv_pipe_pending_count(uv_pipe_t* handle) {
-  if (!handle->ipc)
-    return 0;
-  return handle->pipe.conn.ipc_xfer_queue_length;
-}
-
-
-int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size) {
-  if (handle->flags & UV_HANDLE_BOUND)
-    return uv__pipe_getname(handle, buffer, size);
-
-  if (handle->flags & UV_HANDLE_CONNECTION ||
-      handle->handle != INVALID_HANDLE_VALUE) {
-    *size = 0;
-    return 0;
-  }
-
-  return UV_EBADF;
-}
-
-
-int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size) {
-  /* emulate unix behaviour */
-  if (handle->flags & UV_HANDLE_BOUND)
-    return UV_ENOTCONN;
-
-  if (handle->handle != INVALID_HANDLE_VALUE)
-    return uv__pipe_getname(handle, buffer, size);
-
-  return UV_EBADF;
-}
-
-
-uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle) {
-  if (!handle->ipc)
-    return UV_UNKNOWN_HANDLE;
-  if (handle->pipe.conn.ipc_xfer_queue_length == 0)
-    return UV_UNKNOWN_HANDLE;
-  else
-    return UV_TCP;
-}
-
-int uv_pipe_chmod(uv_pipe_t* handle, int mode) {
-  SID_IDENTIFIER_AUTHORITY sid_world = { SECURITY_WORLD_SID_AUTHORITY };
-  PACL old_dacl, new_dacl;
-  PSECURITY_DESCRIPTOR sd;
-  EXPLICIT_ACCESS ea;
-  PSID everyone;
-  int error;
-
-  if (handle == NULL || handle->handle == INVALID_HANDLE_VALUE)
-    return UV_EBADF;
-
-  if (mode != UV_READABLE &&
-      mode != UV_WRITABLE &&
-      mode != (UV_WRITABLE | UV_READABLE))
-    return UV_EINVAL;
-
-  if (!AllocateAndInitializeSid(&sid_world,
-                                1,
-                                SECURITY_WORLD_RID,
-                                0, 0, 0, 0, 0, 0, 0,
-                                &everyone)) {
-    error = GetLastError();
-    goto done;
-  }
-
-  if (GetSecurityInfo(handle->handle,
-                      SE_KERNEL_OBJECT,
-                      DACL_SECURITY_INFORMATION,
-                      NULL,
-                      NULL,
-                      &old_dacl,
-                      NULL,
-                      &sd)) {
-    error = GetLastError();
-    goto clean_sid;
-  }
-
-  memset(&ea, 0, sizeof(EXPLICIT_ACCESS));
-  if (mode & UV_READABLE)
-    ea.grfAccessPermissions |= GENERIC_READ | FILE_WRITE_ATTRIBUTES;
-  if (mode & UV_WRITABLE)
-    ea.grfAccessPermissions |= GENERIC_WRITE | FILE_READ_ATTRIBUTES;
-  ea.grfAccessPermissions |= SYNCHRONIZE;
-  ea.grfAccessMode = SET_ACCESS;
-  ea.grfInheritance = NO_INHERITANCE;
-  ea.Trustee.TrusteeForm = TRUSTEE_IS_SID;
-  ea.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
-  ea.Trustee.ptstrName = (LPTSTR)everyone;
-
-  if (SetEntriesInAcl(1, &ea, old_dacl, &new_dacl)) {
-    error = GetLastError();
-    goto clean_sd;
-  }
-
-  if (SetSecurityInfo(handle->handle,
-                      SE_KERNEL_OBJECT,
-                      DACL_SECURITY_INFORMATION,
-                      NULL,
-                      NULL,
-                      new_dacl,
-                      NULL)) {
-    error = GetLastError();
-    goto clean_dacl;
-  }
-
-  error = 0;
-
-clean_dacl:
-  LocalFree((HLOCAL) new_dacl);
-clean_sd:
-  LocalFree((HLOCAL) sd);
-clean_sid:
-  FreeSid(everyone);
-done:
-  return uv_translate_sys_error(error);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/poll.cpp b/wpiutil/src/main/native/libuv/src/win/poll.cpp
deleted file mode 100644
index 3c66786..0000000
--- a/wpiutil/src/main/native/libuv/src/win/poll.cpp
+++ /dev/null
@@ -1,643 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <io.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-static const GUID uv_msafd_provider_ids[UV_MSAFD_PROVIDER_COUNT] = {
-  {0xe70f1aa0, 0xab8b, 0x11cf,
-      {0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
-  {0xf9eab0c0, 0x26d4, 0x11d0,
-      {0xbb, 0xbf, 0x00, 0xaa, 0x00, 0x6c, 0x34, 0xe4}},
-  {0x9fc48064, 0x7298, 0x43e4,
-      {0xb7, 0xbd, 0x18, 0x1f, 0x20, 0x89, 0x79, 0x2a}}
-};
-
-typedef struct uv_single_fd_set_s {
-  unsigned int fd_count;
-  SOCKET fd_array[1];
-} uv_single_fd_set_t;
-
-
-static OVERLAPPED overlapped_dummy_;
-static uv_once_t overlapped_dummy_init_guard_ = UV_ONCE_INIT;
-
-static AFD_POLL_INFO afd_poll_info_dummy_;
-
-
-static void uv__init_overlapped_dummy(void) {
-  HANDLE event;
-
-  event = CreateEvent(NULL, TRUE, TRUE, NULL);
-  if (event == NULL)
-    uv_fatal_error(GetLastError(), "CreateEvent");
-
-  memset(&overlapped_dummy_, 0, sizeof overlapped_dummy_);
-  overlapped_dummy_.hEvent = (HANDLE) ((uintptr_t) event | 1);
-}
-
-
-static OVERLAPPED* uv__get_overlapped_dummy(void) {
-  uv_once(&overlapped_dummy_init_guard_, uv__init_overlapped_dummy);
-  return &overlapped_dummy_;
-}
-
-
-static AFD_POLL_INFO* uv__get_afd_poll_info_dummy(void) {
-  return &afd_poll_info_dummy_;
-}
-
-
-static void uv__fast_poll_submit_poll_req(uv_loop_t* loop, uv_poll_t* handle) {
-  uv_req_t* req;
-  AFD_POLL_INFO* afd_poll_info;
-  int result;
-
-  /* Find a yet unsubmitted req to submit. */
-  if (handle->submitted_events_1 == 0) {
-    req = &handle->poll_req_1;
-    afd_poll_info = &handle->afd_poll_info_1;
-    handle->submitted_events_1 = handle->events;
-    handle->mask_events_1 = 0;
-    handle->mask_events_2 = handle->events;
-  } else if (handle->submitted_events_2 == 0) {
-    req = &handle->poll_req_2;
-    afd_poll_info = &handle->afd_poll_info_2;
-    handle->submitted_events_2 = handle->events;
-    handle->mask_events_1 = handle->events;
-    handle->mask_events_2 = 0;
-  } else {
-    /* Just wait until there's an unsubmitted req. This will happen almost
-     * immediately as one of the 2 outstanding requests is about to return.
-     * When this happens, uv__fast_poll_process_poll_req will be called, and
-     * the pending events, if needed, will be processed in a subsequent
-     * request. */
-    return;
-  }
-
-  /* Setting Exclusive to TRUE makes the other poll request return if there is
-   * any. */
-  afd_poll_info->Exclusive = TRUE;
-  afd_poll_info->NumberOfHandles = 1;
-  afd_poll_info->Timeout.QuadPart = INT64_MAX;
-  afd_poll_info->Handles[0].Handle = (HANDLE) handle->socket;
-  afd_poll_info->Handles[0].Status = 0;
-  afd_poll_info->Handles[0].Events = 0;
-
-  if (handle->events & UV_READABLE) {
-    afd_poll_info->Handles[0].Events |= AFD_POLL_RECEIVE |
-        AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT;
-  } else {
-    if (handle->events & UV_DISCONNECT) {
-      afd_poll_info->Handles[0].Events |= AFD_POLL_DISCONNECT;
-    }
-  }
-  if (handle->events & UV_WRITABLE) {
-    afd_poll_info->Handles[0].Events |= AFD_POLL_SEND | AFD_POLL_CONNECT_FAIL;
-  }
-
-  memset(&req->u.io.overlapped, 0, sizeof req->u.io.overlapped);
-
-  result = uv_msafd_poll((SOCKET) handle->peer_socket,
-                         afd_poll_info,
-                         afd_poll_info,
-                         &req->u.io.overlapped);
-  if (result != 0 && WSAGetLastError() != WSA_IO_PENDING) {
-    /* Queue this req, reporting an error. */
-    SET_REQ_ERROR(req, WSAGetLastError());
-    uv_insert_pending_req(loop, req);
-  }
-}
-
-
-static int uv__fast_poll_cancel_poll_req(uv_loop_t* loop, uv_poll_t* handle) {
-  AFD_POLL_INFO afd_poll_info;
-  int result;
-
-  afd_poll_info.Exclusive = TRUE;
-  afd_poll_info.NumberOfHandles = 1;
-  afd_poll_info.Timeout.QuadPart = INT64_MAX;
-  afd_poll_info.Handles[0].Handle = (HANDLE) handle->socket;
-  afd_poll_info.Handles[0].Status = 0;
-  afd_poll_info.Handles[0].Events = AFD_POLL_ALL;
-
-  result = uv_msafd_poll(handle->socket,
-                         &afd_poll_info,
-                         uv__get_afd_poll_info_dummy(),
-                         uv__get_overlapped_dummy());
-
-  if (result == SOCKET_ERROR) {
-    DWORD error = WSAGetLastError();
-    if (error != WSA_IO_PENDING)
-      return error;
-  }
-
-  return 0;
-}
-
-
-static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
-    uv_req_t* req) {
-  unsigned char mask_events;
-  AFD_POLL_INFO* afd_poll_info;
-
-  if (req == &handle->poll_req_1) {
-    afd_poll_info = &handle->afd_poll_info_1;
-    handle->submitted_events_1 = 0;
-    mask_events = handle->mask_events_1;
-  } else if (req == &handle->poll_req_2) {
-    afd_poll_info = &handle->afd_poll_info_2;
-    handle->submitted_events_2 = 0;
-    mask_events = handle->mask_events_2;
-  } else {
-    assert(0);
-    return;
-  }
-
-  /* Report an error unless the select was just interrupted. */
-  if (!REQ_SUCCESS(req)) {
-    DWORD error = GET_REQ_SOCK_ERROR(req);
-    if (error != WSAEINTR && handle->events != 0) {
-      handle->events = 0; /* Stop the watcher */
-      handle->poll_cb(handle, uv_translate_sys_error(error), 0);
-    }
-
-  } else if (afd_poll_info->NumberOfHandles >= 1) {
-    unsigned char events = 0;
-
-    if ((afd_poll_info->Handles[0].Events & (AFD_POLL_RECEIVE |
-        AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT)) != 0) {
-      events |= UV_READABLE;
-      if ((afd_poll_info->Handles[0].Events & AFD_POLL_DISCONNECT) != 0) {
-        events |= UV_DISCONNECT;
-      }
-    }
-    if ((afd_poll_info->Handles[0].Events & (AFD_POLL_SEND |
-        AFD_POLL_CONNECT_FAIL)) != 0) {
-      events |= UV_WRITABLE;
-    }
-
-    events &= handle->events & ~mask_events;
-
-    if (afd_poll_info->Handles[0].Events & AFD_POLL_LOCAL_CLOSE) {
-      /* Stop polling. */
-      handle->events = 0;
-      if (uv__is_active(handle))
-        uv__handle_stop(handle);
-    }
-
-    if (events != 0) {
-      handle->poll_cb(handle, 0, events);
-    }
-  }
-
-  if ((handle->events & ~(handle->submitted_events_1 |
-      handle->submitted_events_2)) != 0) {
-    uv__fast_poll_submit_poll_req(loop, handle);
-  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
-             handle->submitted_events_1 == 0 &&
-             handle->submitted_events_2 == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-}
-
-
-static int uv__fast_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
-  assert(handle->type == UV_POLL);
-  assert(!(handle->flags & UV_HANDLE_CLOSING));
-  assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT)) == 0);
-
-  handle->events = events;
-
-  if (handle->events != 0) {
-    uv__handle_start(handle);
-  } else {
-    uv__handle_stop(handle);
-  }
-
-  if ((handle->events & ~(handle->submitted_events_1 |
-      handle->submitted_events_2)) != 0) {
-    uv__fast_poll_submit_poll_req(handle->loop, handle);
-  }
-
-  return 0;
-}
-
-
-static int uv__fast_poll_close(uv_loop_t* loop, uv_poll_t* handle) {
-  handle->events = 0;
-  uv__handle_closing(handle);
-
-  if (handle->submitted_events_1 == 0 &&
-      handle->submitted_events_2 == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-    return 0;
-  } else {
-    /* Cancel outstanding poll requests by executing another, unique poll
-     * request that forces the outstanding ones to return. */
-    return uv__fast_poll_cancel_poll_req(loop, handle);
-  }
-}
-
-
-static SOCKET uv__fast_poll_create_peer_socket(HANDLE iocp,
-    WSAPROTOCOL_INFOW* protocol_info) {
-  SOCKET sock = 0;
-
-  sock = WSASocketW(protocol_info->iAddressFamily,
-                    protocol_info->iSocketType,
-                    protocol_info->iProtocol,
-                    protocol_info,
-                    0,
-                    WSA_FLAG_OVERLAPPED);
-  if (sock == INVALID_SOCKET) {
-    return INVALID_SOCKET;
-  }
-
-  if (!SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0)) {
-    goto error;
-  };
-
-  if (CreateIoCompletionPort((HANDLE) sock,
-                             iocp,
-                             (ULONG_PTR) sock,
-                             0) == NULL) {
-    goto error;
-  }
-
-  return sock;
-
- error:
-  closesocket(sock);
-  return INVALID_SOCKET;
-}
-
-
-static SOCKET uv__fast_poll_get_peer_socket(uv_loop_t* loop,
-    WSAPROTOCOL_INFOW* protocol_info) {
-  int index, i;
-  SOCKET peer_socket;
-
-  index = -1;
-  for (i = 0; (size_t) i < ARRAY_SIZE(uv_msafd_provider_ids); i++) {
-    if (memcmp((void*) &protocol_info->ProviderId,
-               (void*) &uv_msafd_provider_ids[i],
-               sizeof protocol_info->ProviderId) == 0) {
-      index = i;
-    }
-  }
-
-  /* Check if the protocol uses an msafd socket. */
-  if (index < 0) {
-    return INVALID_SOCKET;
-  }
-
-  /* If we didn't (try) to create a peer socket yet, try to make one. Don't try
-   * again if the peer socket creation failed earlier for the same protocol. */
-  peer_socket = loop->poll_peer_sockets[index];
-  if (peer_socket == 0) {
-    peer_socket = uv__fast_poll_create_peer_socket(loop->iocp, protocol_info);
-    loop->poll_peer_sockets[index] = peer_socket;
-  }
-
-  return peer_socket;
-}
-
-
-static DWORD WINAPI uv__slow_poll_thread_proc(void* arg) {
-  uv_req_t* req = (uv_req_t*) arg;
-  uv_poll_t* handle = (uv_poll_t*) req->data;
-  unsigned char reported_events;
-  int r;
-  uv_single_fd_set_t rfds, wfds, efds;
-  struct timeval timeout;
-
-  assert(handle->type == UV_POLL);
-  assert(req->type == UV_POLL_REQ);
-
-  if (handle->events & UV_READABLE) {
-    rfds.fd_count = 1;
-    rfds.fd_array[0] = handle->socket;
-  } else {
-    rfds.fd_count = 0;
-  }
-
-  if (handle->events & UV_WRITABLE) {
-    wfds.fd_count = 1;
-    wfds.fd_array[0] = handle->socket;
-    efds.fd_count = 1;
-    efds.fd_array[0] = handle->socket;
-  } else {
-    wfds.fd_count = 0;
-    efds.fd_count = 0;
-  }
-
-  /* Make the select() time out after 3 minutes. If select() hangs because the
-   * user closed the socket, we will at least not hang indefinitely. */
-  timeout.tv_sec = 3 * 60;
-  timeout.tv_usec = 0;
-
-  r = select(1, (fd_set*) &rfds, (fd_set*) &wfds, (fd_set*) &efds, &timeout);
-  if (r == SOCKET_ERROR) {
-    /* Queue this req, reporting an error. */
-    SET_REQ_ERROR(&handle->poll_req_1, WSAGetLastError());
-    POST_COMPLETION_FOR_REQ(handle->loop, req);
-    return 0;
-  }
-
-  reported_events = 0;
-
-  if (r > 0) {
-    if (rfds.fd_count > 0) {
-      assert(rfds.fd_count == 1);
-      assert(rfds.fd_array[0] == handle->socket);
-      reported_events |= UV_READABLE;
-    }
-
-    if (wfds.fd_count > 0) {
-      assert(wfds.fd_count == 1);
-      assert(wfds.fd_array[0] == handle->socket);
-      reported_events |= UV_WRITABLE;
-    } else if (efds.fd_count > 0) {
-      assert(efds.fd_count == 1);
-      assert(efds.fd_array[0] == handle->socket);
-      reported_events |= UV_WRITABLE;
-    }
-  }
-
-  SET_REQ_SUCCESS(req);
-  req->u.io.overlapped.InternalHigh = (DWORD) reported_events;
-  POST_COMPLETION_FOR_REQ(handle->loop, req);
-
-  return 0;
-}
-
-
-static void uv__slow_poll_submit_poll_req(uv_loop_t* loop, uv_poll_t* handle) {
-  uv_req_t* req;
-
-  /* Find a yet unsubmitted req to submit. */
-  if (handle->submitted_events_1 == 0) {
-    req = &handle->poll_req_1;
-    handle->submitted_events_1 = handle->events;
-    handle->mask_events_1 = 0;
-    handle->mask_events_2 = handle->events;
-  } else if (handle->submitted_events_2 == 0) {
-    req = &handle->poll_req_2;
-    handle->submitted_events_2 = handle->events;
-    handle->mask_events_1 = handle->events;
-    handle->mask_events_2 = 0;
-  } else {
-    assert(0);
-    return;
-  }
-
-  if (!QueueUserWorkItem(uv__slow_poll_thread_proc,
-                         (void*) req,
-                         WT_EXECUTELONGFUNCTION)) {
-    /* Make this req pending, reporting an error. */
-    SET_REQ_ERROR(req, GetLastError());
-    uv_insert_pending_req(loop, req);
-  }
-}
-
-
-
-static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
-    uv_req_t* req) {
-  unsigned char mask_events;
-  int err;
-
-  if (req == &handle->poll_req_1) {
-    handle->submitted_events_1 = 0;
-    mask_events = handle->mask_events_1;
-  } else if (req == &handle->poll_req_2) {
-    handle->submitted_events_2 = 0;
-    mask_events = handle->mask_events_2;
-  } else {
-    assert(0);
-    return;
-  }
-
-  if (!REQ_SUCCESS(req)) {
-    /* Error. */
-    if (handle->events != 0) {
-      err = GET_REQ_ERROR(req);
-      handle->events = 0; /* Stop the watcher */
-      handle->poll_cb(handle, uv_translate_sys_error(err), 0);
-    }
-  } else {
-    /* Got some events. */
-    int events = req->u.io.overlapped.InternalHigh & handle->events & ~mask_events;
-    if (events != 0) {
-      handle->poll_cb(handle, 0, events);
-    }
-  }
-
-  if ((handle->events & ~(handle->submitted_events_1 |
-      handle->submitted_events_2)) != 0) {
-    uv__slow_poll_submit_poll_req(loop, handle);
-  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
-             handle->submitted_events_1 == 0 &&
-             handle->submitted_events_2 == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-}
-
-
-static int uv__slow_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
-  assert(handle->type == UV_POLL);
-  assert(!(handle->flags & UV_HANDLE_CLOSING));
-  assert((events & ~(UV_READABLE | UV_WRITABLE)) == 0);
-
-  handle->events = events;
-
-  if (handle->events != 0) {
-    uv__handle_start(handle);
-  } else {
-    uv__handle_stop(handle);
-  }
-
-  if ((handle->events &
-      ~(handle->submitted_events_1 | handle->submitted_events_2)) != 0) {
-    uv__slow_poll_submit_poll_req(handle->loop, handle);
-  }
-
-  return 0;
-}
-
-
-static int uv__slow_poll_close(uv_loop_t* loop, uv_poll_t* handle) {
-  handle->events = 0;
-  uv__handle_closing(handle);
-
-  if (handle->submitted_events_1 == 0 &&
-      handle->submitted_events_2 == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-
-  return 0;
-}
-
-
-int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {
-  return uv_poll_init_socket(loop, handle, (SOCKET) uv__get_osfhandle(fd));
-}
-
-
-int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
-    uv_os_sock_t socket) {
-  WSAPROTOCOL_INFOW protocol_info;
-  int len;
-  SOCKET peer_socket, base_socket;
-  DWORD bytes;
-  DWORD yes = 1;
-
-  /* Set the socket to nonblocking mode */
-  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR)
-    return uv_translate_sys_error(WSAGetLastError());
-
-/* Try to obtain a base handle for the socket. This increases this chances that
- * we find an AFD handle and are able to use the fast poll mechanism. This will
- * always fail on windows XP/2k3, since they don't support the. SIO_BASE_HANDLE
- * ioctl. */
-#ifndef NDEBUG
-  base_socket = INVALID_SOCKET;
-#endif
-
-  if (WSAIoctl(socket,
-               SIO_BASE_HANDLE,
-               NULL,
-               0,
-               &base_socket,
-               sizeof base_socket,
-               &bytes,
-               NULL,
-               NULL) == 0) {
-    assert(base_socket != 0 && base_socket != INVALID_SOCKET);
-    socket = base_socket;
-  }
-
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
-  handle->socket = socket;
-  handle->events = 0;
-
-  /* Obtain protocol information about the socket. */
-  len = sizeof protocol_info;
-  if (getsockopt(socket,
-                 SOL_SOCKET,
-                 SO_PROTOCOL_INFOW,
-                 (char*) &protocol_info,
-                 &len) != 0) {
-    return uv_translate_sys_error(WSAGetLastError());
-  }
-
-  /* Get the peer socket that is needed to enable fast poll. If the returned
-   * value is NULL, the protocol is not implemented by MSAFD and we'll have to
-   * use slow mode. */
-  peer_socket = uv__fast_poll_get_peer_socket(loop, &protocol_info);
-
-  if (peer_socket != INVALID_SOCKET) {
-    /* Initialize fast poll specific fields. */
-    handle->peer_socket = peer_socket;
-  } else {
-    /* Initialize slow poll specific fields. */
-    handle->flags |= UV_HANDLE_POLL_SLOW;
-  }
-
-  /* Initialize 2 poll reqs. */
-  handle->submitted_events_1 = 0;
-  UV_REQ_INIT(&handle->poll_req_1, UV_POLL_REQ);
-  handle->poll_req_1.data = handle;
-
-  handle->submitted_events_2 = 0;
-  UV_REQ_INIT(&handle->poll_req_2, UV_POLL_REQ);
-  handle->poll_req_2.data = handle;
-
-  return 0;
-}
-
-
-int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb) {
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
-    err = uv__fast_poll_set(handle->loop, handle, events);
-  } else {
-    err = uv__slow_poll_set(handle->loop, handle, events);
-  }
-
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  handle->poll_cb = cb;
-
-  return 0;
-}
-
-
-int uv_poll_stop(uv_poll_t* handle) {
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
-    err = uv__fast_poll_set(handle->loop, handle, 0);
-  } else {
-    err = uv__slow_poll_set(handle->loop, handle, 0);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-void uv_process_poll_req(uv_loop_t* loop, uv_poll_t* handle, uv_req_t* req) {
-  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
-    uv__fast_poll_process_poll_req(loop, handle, req);
-  } else {
-    uv__slow_poll_process_poll_req(loop, handle, req);
-  }
-}
-
-
-int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle) {
-  if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
-    return uv__fast_poll_close(loop, handle);
-  } else {
-    return uv__slow_poll_close(loop, handle);
-  }
-}
-
-
-void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle) {
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-  assert(handle->submitted_events_1 == 0);
-  assert(handle->submitted_events_2 == 0);
-
-  uv__handle_close(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/process-stdio.cpp b/wpiutil/src/main/native/libuv/src/win/process-stdio.cpp
deleted file mode 100644
index 4701938..0000000
--- a/wpiutil/src/main/native/libuv/src/win/process-stdio.cpp
+++ /dev/null
@@ -1,512 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <io.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-
-
-/*
- * The `child_stdio_buffer` buffer has the following layout:
- *   int number_of_fds
- *   unsigned char crt_flags[number_of_fds]
- *   HANDLE os_handle[number_of_fds]
- */
-#define CHILD_STDIO_SIZE(count)                     \
-    (sizeof(int) +                                  \
-     sizeof(unsigned char) * (count) +              \
-     sizeof(uintptr_t) * (count))
-
-#define CHILD_STDIO_COUNT(buffer)                   \
-    *((unsigned int*) (buffer))
-
-#define CHILD_STDIO_CRT_FLAGS(buffer, fd)           \
-    *((unsigned char*) (buffer) + sizeof(int) + fd)
-
-#define CHILD_STDIO_HANDLE(buffer, fd)              \
-    *((HANDLE*) ((unsigned char*) (buffer) +        \
-                 sizeof(int) +                      \
-                 sizeof(unsigned char) *            \
-                 CHILD_STDIO_COUNT((buffer)) +      \
-                 sizeof(HANDLE) * (fd)))
-
-
-/* CRT file descriptor mode flags */
-#define FOPEN       0x01
-#define FEOFLAG     0x02
-#define FCRLF       0x04
-#define FPIPE       0x08
-#define FNOINHERIT  0x10
-#define FAPPEND     0x20
-#define FDEV        0x40
-#define FTEXT       0x80
-
-
-/*
- * Clear the HANDLE_FLAG_INHERIT flag from all HANDLEs that were inherited
- * the parent process. Don't check for errors - the stdio handles may not be
- * valid, or may be closed already. There is no guarantee that this function
- * does a perfect job.
- */
-void uv_disable_stdio_inheritance(void) {
-  HANDLE handle;
-  STARTUPINFOW si;
-
-  /* Make the windows stdio handles non-inheritable. */
-  handle = GetStdHandle(STD_INPUT_HANDLE);
-  if (handle != NULL && handle != INVALID_HANDLE_VALUE)
-    SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
-
-  handle = GetStdHandle(STD_OUTPUT_HANDLE);
-  if (handle != NULL && handle != INVALID_HANDLE_VALUE)
-    SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
-
-  handle = GetStdHandle(STD_ERROR_HANDLE);
-  if (handle != NULL && handle != INVALID_HANDLE_VALUE)
-    SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
-
-  /* Make inherited CRT FDs non-inheritable. */
-  GetStartupInfoW(&si);
-  if (uv__stdio_verify(si.lpReserved2, si.cbReserved2))
-    uv__stdio_noinherit(si.lpReserved2);
-}
-
-
-static int uv__create_stdio_pipe_pair(uv_loop_t* loop,
-    uv_pipe_t* server_pipe, HANDLE* child_pipe_ptr, unsigned int flags) {
-  char pipe_name[64];
-  SECURITY_ATTRIBUTES sa;
-  DWORD server_access = 0;
-  DWORD client_access = 0;
-  HANDLE child_pipe = INVALID_HANDLE_VALUE;
-  int err;
-  BOOL overlap;
-
-  if (flags & UV_READABLE_PIPE) {
-    /* The server needs inbound access too, otherwise CreateNamedPipe() won't
-     * give us the FILE_READ_ATTRIBUTES permission. We need that to probe the
-     * state of the write buffer when we're trying to shutdown the pipe. */
-    server_access |= PIPE_ACCESS_OUTBOUND | PIPE_ACCESS_INBOUND;
-    client_access |= GENERIC_READ | FILE_WRITE_ATTRIBUTES;
-  }
-  if (flags & UV_WRITABLE_PIPE) {
-    server_access |= PIPE_ACCESS_INBOUND;
-    client_access |= GENERIC_WRITE | FILE_READ_ATTRIBUTES;
-  }
-
-  /* Create server pipe handle. */
-  err = uv_stdio_pipe_server(loop,
-                             server_pipe,
-                             server_access,
-                             pipe_name,
-                             sizeof(pipe_name));
-  if (err)
-    goto error;
-
-  /* Create child pipe handle. */
-  sa.nLength = sizeof sa;
-  sa.lpSecurityDescriptor = NULL;
-  sa.bInheritHandle = TRUE;
-
-  overlap = server_pipe->ipc || (flags & UV_OVERLAPPED_PIPE);
-  child_pipe = CreateFileA(pipe_name,
-                           client_access,
-                           0,
-                           &sa,
-                           OPEN_EXISTING,
-                           overlap ? FILE_FLAG_OVERLAPPED : 0,
-                           NULL);
-  if (child_pipe == INVALID_HANDLE_VALUE) {
-    err = GetLastError();
-    goto error;
-  }
-
-#ifndef NDEBUG
-  /* Validate that the pipe was opened in the right mode. */
-  {
-    DWORD mode;
-    BOOL r = GetNamedPipeHandleState(child_pipe,
-                                     &mode,
-                                     NULL,
-                                     NULL,
-                                     NULL,
-                                     NULL,
-                                     0);
-    assert(r == TRUE);
-    assert(mode == (PIPE_READMODE_BYTE | PIPE_WAIT));
-  }
-#endif
-
-  /* Do a blocking ConnectNamedPipe. This should not block because we have both
-   * ends of the pipe created. */
-  if (!ConnectNamedPipe(server_pipe->handle, NULL)) {
-    if (GetLastError() != ERROR_PIPE_CONNECTED) {
-      err = GetLastError();
-      goto error;
-    }
-  }
-
-  /* The server end is now readable and/or writable. */
-  if (flags & UV_READABLE_PIPE)
-    server_pipe->flags |= UV_HANDLE_WRITABLE;
-  if (flags & UV_WRITABLE_PIPE)
-    server_pipe->flags |= UV_HANDLE_READABLE;
-
-  *child_pipe_ptr = child_pipe;
-  return 0;
-
- error:
-  if (server_pipe->handle != INVALID_HANDLE_VALUE) {
-    uv_pipe_cleanup(loop, server_pipe);
-  }
-
-  if (child_pipe != INVALID_HANDLE_VALUE) {
-    CloseHandle(child_pipe);
-  }
-
-  return err;
-}
-
-
-static int uv__duplicate_handle(uv_loop_t* loop, HANDLE handle, HANDLE* dup) {
-  HANDLE current_process;
-
-
-  /* _get_osfhandle will sometimes return -2 in case of an error. This seems to
-   * happen when fd <= 2 and the process' corresponding stdio handle is set to
-   * NULL. Unfortunately DuplicateHandle will happily duplicate (HANDLE) -2, so
-   * this situation goes unnoticed until someone tries to use the duplicate.
-   * Therefore we filter out known-invalid handles here. */
-  if (handle == INVALID_HANDLE_VALUE ||
-      handle == NULL ||
-      handle == (HANDLE) -2) {
-    *dup = INVALID_HANDLE_VALUE;
-    return ERROR_INVALID_HANDLE;
-  }
-
-  current_process = GetCurrentProcess();
-
-  if (!DuplicateHandle(current_process,
-                       handle,
-                       current_process,
-                       dup,
-                       0,
-                       TRUE,
-                       DUPLICATE_SAME_ACCESS)) {
-    *dup = INVALID_HANDLE_VALUE;
-    return GetLastError();
-  }
-
-  return 0;
-}
-
-
-static int uv__duplicate_fd(uv_loop_t* loop, int fd, HANDLE* dup) {
-  HANDLE handle;
-
-  if (fd == -1) {
-    *dup = INVALID_HANDLE_VALUE;
-    return ERROR_INVALID_HANDLE;
-  }
-
-  handle = uv__get_osfhandle(fd);
-  return uv__duplicate_handle(loop, handle, dup);
-}
-
-
-int uv__create_nul_handle(HANDLE* handle_ptr,
-    DWORD access) {
-  HANDLE handle;
-  SECURITY_ATTRIBUTES sa;
-
-  sa.nLength = sizeof sa;
-  sa.lpSecurityDescriptor = NULL;
-  sa.bInheritHandle = TRUE;
-
-  handle = CreateFileW(L"NUL",
-                       access,
-                       FILE_SHARE_READ | FILE_SHARE_WRITE,
-                       &sa,
-                       OPEN_EXISTING,
-                       0,
-                       NULL);
-  if (handle == INVALID_HANDLE_VALUE) {
-    return GetLastError();
-  }
-
-  *handle_ptr = handle;
-  return 0;
-}
-
-
-int uv__stdio_create(uv_loop_t* loop,
-                     const uv_process_options_t* options,
-                     BYTE** buffer_ptr) {
-  BYTE* buffer;
-  int count, i;
-  int err;
-
-  count = options->stdio_count;
-
-  if (count < 0 || count > 255) {
-    /* Only support FDs 0-255 */
-    return ERROR_NOT_SUPPORTED;
-  } else if (count < 3) {
-    /* There should always be at least 3 stdio handles. */
-    count = 3;
-  }
-
-  /* Allocate the child stdio buffer */
-  buffer = (BYTE*) uv__malloc(CHILD_STDIO_SIZE(count));
-  if (buffer == NULL) {
-    return ERROR_OUTOFMEMORY;
-  }
-
-  /* Prepopulate the buffer with INVALID_HANDLE_VALUE handles so we can clean
-   * up on failure. */
-  CHILD_STDIO_COUNT(buffer) = count;
-  for (i = 0; i < count; i++) {
-    CHILD_STDIO_CRT_FLAGS(buffer, i) = 0;
-    CHILD_STDIO_HANDLE(buffer, i) = INVALID_HANDLE_VALUE;
-  }
-
-  for (i = 0; i < count; i++) {
-    uv_stdio_container_t fdopt;
-    if (i < options->stdio_count) {
-      fdopt = options->stdio[i];
-    } else {
-      fdopt.flags = UV_IGNORE;
-    }
-
-    switch (fdopt.flags & (UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD |
-            UV_INHERIT_STREAM)) {
-      case UV_IGNORE:
-        /* Starting a process with no stdin/stout/stderr can confuse it. So no
-         * matter what the user specified, we make sure the first three FDs are
-         * always open in their typical modes, e. g. stdin be readable and
-         * stdout/err should be writable. For FDs > 2, don't do anything - all
-         * handles in the stdio buffer are initialized with.
-         * INVALID_HANDLE_VALUE, which should be okay. */
-        if (i <= 2) {
-          DWORD access = (i == 0) ? FILE_GENERIC_READ :
-                                    FILE_GENERIC_WRITE | FILE_READ_ATTRIBUTES;
-
-          err = uv__create_nul_handle(&CHILD_STDIO_HANDLE(buffer, i),
-                                      access);
-          if (err)
-            goto error;
-
-          CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
-        }
-        break;
-
-      case UV_CREATE_PIPE: {
-        /* Create a pair of two connected pipe ends; one end is turned into an
-         * uv_pipe_t for use by the parent. The other one is given to the
-         * child. */
-        uv_pipe_t* parent_pipe = (uv_pipe_t*) fdopt.data.stream;
-        HANDLE child_pipe = INVALID_HANDLE_VALUE;
-
-        /* Create a new, connected pipe pair. stdio[i]. stream should point to
-         * an uninitialized, but not connected pipe handle. */
-        assert(fdopt.data.stream->type == UV_NAMED_PIPE);
-        assert(!(fdopt.data.stream->flags & UV_HANDLE_CONNECTION));
-        assert(!(fdopt.data.stream->flags & UV_HANDLE_PIPESERVER));
-
-        err = uv__create_stdio_pipe_pair(loop,
-                                         parent_pipe,
-                                         &child_pipe,
-                                         fdopt.flags);
-        if (err)
-          goto error;
-
-        CHILD_STDIO_HANDLE(buffer, i) = child_pipe;
-        CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FPIPE;
-        break;
-      }
-
-      case UV_INHERIT_FD: {
-        /* Inherit a raw FD. */
-        HANDLE child_handle;
-
-        /* Make an inheritable duplicate of the handle. */
-        err = uv__duplicate_fd(loop, fdopt.data.fd, &child_handle);
-        if (err) {
-          /* If fdopt. data. fd is not valid and fd <= 2, then ignore the
-           * error. */
-          if (fdopt.data.fd <= 2 && err == ERROR_INVALID_HANDLE) {
-            CHILD_STDIO_CRT_FLAGS(buffer, i) = 0;
-            CHILD_STDIO_HANDLE(buffer, i) = INVALID_HANDLE_VALUE;
-            break;
-          }
-          goto error;
-        }
-
-        /* Figure out what the type is. */
-        switch (GetFileType(child_handle)) {
-          case FILE_TYPE_DISK:
-            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN;
-            break;
-
-          case FILE_TYPE_PIPE:
-            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FPIPE;
-            break;
-
-          case FILE_TYPE_CHAR:
-          case FILE_TYPE_REMOTE:
-            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
-            break;
-
-          case FILE_TYPE_UNKNOWN:
-            if (GetLastError() != 0) {
-              err = GetLastError();
-              CloseHandle(child_handle);
-              goto error;
-            }
-            CHILD_STDIO_CRT_FLAGS(buffer, i) = FOPEN | FDEV;
-            break;
-
-          default:
-            assert(0);
-            return -1;
-        }
-
-        CHILD_STDIO_HANDLE(buffer, i) = child_handle;
-        break;
-      }
-
-      case UV_INHERIT_STREAM: {
-        /* Use an existing stream as the stdio handle for the child. */
-        HANDLE stream_handle, child_handle;
-        unsigned char crt_flags;
-        uv_stream_t* stream = fdopt.data.stream;
-
-        /* Leech the handle out of the stream. */
-        if (stream->type == UV_TTY) {
-          stream_handle = ((uv_tty_t*) stream)->handle;
-          crt_flags = FOPEN | FDEV;
-        } else if (stream->type == UV_NAMED_PIPE &&
-                   stream->flags & UV_HANDLE_CONNECTION) {
-          stream_handle = ((uv_pipe_t*) stream)->handle;
-          crt_flags = FOPEN | FPIPE;
-        } else {
-          stream_handle = INVALID_HANDLE_VALUE;
-          crt_flags = 0;
-        }
-
-        if (stream_handle == NULL ||
-            stream_handle == INVALID_HANDLE_VALUE) {
-          /* The handle is already closed, or not yet created, or the stream
-           * type is not supported. */
-          err = ERROR_NOT_SUPPORTED;
-          goto error;
-        }
-
-        /* Make an inheritable copy of the handle. */
-        err = uv__duplicate_handle(loop, stream_handle, &child_handle);
-        if (err)
-          goto error;
-
-        CHILD_STDIO_HANDLE(buffer, i) = child_handle;
-        CHILD_STDIO_CRT_FLAGS(buffer, i) = crt_flags;
-        break;
-      }
-
-      default:
-        assert(0);
-        return -1;
-    }
-  }
-
-  *buffer_ptr  = buffer;
-  return 0;
-
- error:
-  uv__stdio_destroy(buffer);
-  return err;
-}
-
-
-void uv__stdio_destroy(BYTE* buffer) {
-  int i, count;
-
-  count = CHILD_STDIO_COUNT(buffer);
-  for (i = 0; i < count; i++) {
-    HANDLE handle = CHILD_STDIO_HANDLE(buffer, i);
-    if (handle != INVALID_HANDLE_VALUE) {
-      CloseHandle(handle);
-    }
-  }
-
-  uv__free(buffer);
-}
-
-
-void uv__stdio_noinherit(BYTE* buffer) {
-  int i, count;
-
-  count = CHILD_STDIO_COUNT(buffer);
-  for (i = 0; i < count; i++) {
-    HANDLE handle = CHILD_STDIO_HANDLE(buffer, i);
-    if (handle != INVALID_HANDLE_VALUE) {
-      SetHandleInformation(handle, HANDLE_FLAG_INHERIT, 0);
-    }
-  }
-}
-
-
-int uv__stdio_verify(BYTE* buffer, WORD size) {
-  unsigned int count;
-
-  /* Check the buffer pointer. */
-  if (buffer == NULL)
-    return 0;
-
-  /* Verify that the buffer is at least big enough to hold the count. */
-  if (size < CHILD_STDIO_SIZE(0))
-    return 0;
-
-  /* Verify if the count is within range. */
-  count = CHILD_STDIO_COUNT(buffer);
-  if (count > 256)
-    return 0;
-
-  /* Verify that the buffer size is big enough to hold info for N FDs. */
-  if (size < CHILD_STDIO_SIZE(count))
-    return 0;
-
-  return 1;
-}
-
-
-WORD uv__stdio_size(BYTE* buffer) {
-  return (WORD) CHILD_STDIO_SIZE(CHILD_STDIO_COUNT((buffer)));
-}
-
-
-HANDLE uv__stdio_handle(BYTE* buffer, int fd) {
-  return CHILD_STDIO_HANDLE(buffer, fd);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/process.cpp b/wpiutil/src/main/native/libuv/src/win/process.cpp
deleted file mode 100644
index 3b8675a..0000000
--- a/wpiutil/src/main/native/libuv/src/win/process.cpp
+++ /dev/null
@@ -1,1284 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#define _CRT_NONSTDC_NO_WARNINGS
-
-#include <assert.h>
-#include <io.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <limits.h>
-#include <wchar.h>
-#include <malloc.h>    /* alloca */
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-#define SIGKILL         9
-
-
-typedef struct env_var {
-  const WCHAR* const wide;
-  const WCHAR* const wide_eq;
-  const size_t len; /* including null or '=' */
-} env_var_t;
-
-#define E_V(str) { L##str, L##str L"=", sizeof(str) }
-
-static const env_var_t required_vars[] = { /* keep me sorted */
-  E_V("HOMEDRIVE"),
-  E_V("HOMEPATH"),
-  E_V("LOGONSERVER"),
-  E_V("PATH"),
-  E_V("SYSTEMDRIVE"),
-  E_V("SYSTEMROOT"),
-  E_V("TEMP"),
-  E_V("USERDOMAIN"),
-  E_V("USERNAME"),
-  E_V("USERPROFILE"),
-  E_V("WINDIR"),
-};
-static size_t n_required_vars = ARRAY_SIZE(required_vars);
-
-
-static HANDLE uv_global_job_handle_;
-static uv_once_t uv_global_job_handle_init_guard_ = UV_ONCE_INIT;
-
-
-static void uv__init_global_job_handle(void) {
-  /* Create a job object and set it up to kill all contained processes when
-   * it's closed. Since this handle is made non-inheritable and we're not
-   * giving it to anyone, we're the only process holding a reference to it.
-   * That means that if this process exits it is closed and all the processes
-   * it contains are killed. All processes created with uv_spawn that are not
-   * spawned with the UV_PROCESS_DETACHED flag are assigned to this job.
-   *
-   * We're setting the JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK flag so only the
-   * processes that we explicitly add are affected, and *their* subprocesses
-   * are not. This ensures that our child processes are not limited in their
-   * ability to use job control on Windows versions that don't deal with
-   * nested jobs (prior to Windows 8 / Server 2012). It also lets our child
-   * processes created detached processes without explicitly breaking away
-   * from job control (which uv_spawn doesn't, either).
-   */
-  SECURITY_ATTRIBUTES attr;
-  JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
-
-  memset(&attr, 0, sizeof attr);
-  attr.bInheritHandle = FALSE;
-
-  memset(&info, 0, sizeof info);
-  info.BasicLimitInformation.LimitFlags =
-      JOB_OBJECT_LIMIT_BREAKAWAY_OK |
-      JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK |
-      JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION |
-      JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
-
-  uv_global_job_handle_ = CreateJobObjectW(&attr, NULL);
-  if (uv_global_job_handle_ == NULL)
-    uv_fatal_error(GetLastError(), "CreateJobObjectW");
-
-  if (!SetInformationJobObject(uv_global_job_handle_,
-                               JobObjectExtendedLimitInformation,
-                               &info,
-                               sizeof info))
-    uv_fatal_error(GetLastError(), "SetInformationJobObject");
-}
-
-
-static int uv_utf8_to_utf16_alloc(const char* s, WCHAR** ws_ptr) {
-  int ws_len, r;
-  WCHAR* ws;
-
-  ws_len = MultiByteToWideChar(CP_UTF8,
-                               0,
-                               s,
-                               -1,
-                               NULL,
-                               0);
-  if (ws_len <= 0) {
-    return GetLastError();
-  }
-
-  ws = (WCHAR*) uv__malloc(ws_len * sizeof(WCHAR));
-  if (ws == NULL) {
-    return ERROR_OUTOFMEMORY;
-  }
-
-  r = MultiByteToWideChar(CP_UTF8,
-                          0,
-                          s,
-                          -1,
-                          ws,
-                          ws_len);
-  assert(r == ws_len);
-
-  *ws_ptr = ws;
-  return 0;
-}
-
-
-static void uv_process_init(uv_loop_t* loop, uv_process_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_PROCESS);
-  handle->exit_cb = NULL;
-  handle->pid = 0;
-  handle->exit_signal = 0;
-  handle->wait_handle = INVALID_HANDLE_VALUE;
-  handle->process_handle = INVALID_HANDLE_VALUE;
-  handle->child_stdio_buffer = NULL;
-  handle->exit_cb_pending = 0;
-
-  UV_REQ_INIT(&handle->exit_req, UV_PROCESS_EXIT);
-  handle->exit_req.data = handle;
-}
-
-
-/*
- * Path search functions
- */
-
-/*
- * Helper function for search_path
- */
-static WCHAR* search_path_join_test(const WCHAR* dir,
-                                    size_t dir_len,
-                                    const WCHAR* name,
-                                    size_t name_len,
-                                    const WCHAR* ext,
-                                    size_t ext_len,
-                                    const WCHAR* cwd,
-                                    size_t cwd_len) {
-  WCHAR *result, *result_pos;
-  DWORD attrs;
-  if (dir_len > 2 && dir[0] == L'\\' && dir[1] == L'\\') {
-    /* It's a UNC path so ignore cwd */
-    cwd_len = 0;
-  } else if (dir_len >= 1 && (dir[0] == L'/' || dir[0] == L'\\')) {
-    /* It's a full path without drive letter, use cwd's drive letter only */
-    cwd_len = 2;
-  } else if (dir_len >= 2 && dir[1] == L':' &&
-      (dir_len < 3 || (dir[2] != L'/' && dir[2] != L'\\'))) {
-    /* It's a relative path with drive letter (ext.g. D:../some/file)
-     * Replace drive letter in dir by full cwd if it points to the same drive,
-     * otherwise use the dir only.
-     */
-    if (cwd_len < 2 || _wcsnicmp(cwd, dir, 2) != 0) {
-      cwd_len = 0;
-    } else {
-      dir += 2;
-      dir_len -= 2;
-    }
-  } else if (dir_len > 2 && dir[1] == L':') {
-    /* It's an absolute path with drive letter
-     * Don't use the cwd at all
-     */
-    cwd_len = 0;
-  }
-
-  /* Allocate buffer for output */
-  result = result_pos = (WCHAR*)uv__malloc(sizeof(WCHAR) *
-      (cwd_len + 1 + dir_len + 1 + name_len + 1 + ext_len + 1));
-
-  /* Copy cwd */
-  wcsncpy(result_pos, cwd, cwd_len);
-  result_pos += cwd_len;
-
-  /* Add a path separator if cwd didn't end with one */
-  if (cwd_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) {
-    result_pos[0] = L'\\';
-    result_pos++;
-  }
-
-  /* Copy dir */
-  wcsncpy(result_pos, dir, dir_len);
-  result_pos += dir_len;
-
-  /* Add a separator if the dir didn't end with one */
-  if (dir_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) {
-    result_pos[0] = L'\\';
-    result_pos++;
-  }
-
-  /* Copy filename */
-  wcsncpy(result_pos, name, name_len);
-  result_pos += name_len;
-
-  if (ext_len) {
-    /* Add a dot if the filename didn't end with one */
-    if (name_len && result_pos[-1] != '.') {
-      result_pos[0] = L'.';
-      result_pos++;
-    }
-
-    /* Copy extension */
-    wcsncpy(result_pos, ext, ext_len);
-    result_pos += ext_len;
-  }
-
-  /* Null terminator */
-  result_pos[0] = L'\0';
-
-  attrs = GetFileAttributesW(result);
-
-  if (attrs != INVALID_FILE_ATTRIBUTES &&
-      !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
-    return result;
-  }
-
-  uv__free(result);
-  return NULL;
-}
-
-
-/*
- * Helper function for search_path
- */
-static WCHAR* path_search_walk_ext(const WCHAR *dir,
-                                   size_t dir_len,
-                                   const WCHAR *name,
-                                   size_t name_len,
-                                   WCHAR *cwd,
-                                   size_t cwd_len,
-                                   int name_has_ext) {
-  WCHAR* result;
-
-  /* If the name itself has a nonempty extension, try this extension first */
-  if (name_has_ext) {
-    result = search_path_join_test(dir, dir_len,
-                                   name, name_len,
-                                   L"", 0,
-                                   cwd, cwd_len);
-    if (result != NULL) {
-      return result;
-    }
-  }
-
-  /* Try .com extension */
-  result = search_path_join_test(dir, dir_len,
-                                 name, name_len,
-                                 L"com", 3,
-                                 cwd, cwd_len);
-  if (result != NULL) {
-    return result;
-  }
-
-  /* Try .exe extension */
-  result = search_path_join_test(dir, dir_len,
-                                 name, name_len,
-                                 L"exe", 3,
-                                 cwd, cwd_len);
-  if (result != NULL) {
-    return result;
-  }
-
-  return NULL;
-}
-
-
-/*
- * search_path searches the system path for an executable filename -
- * the windows API doesn't provide this as a standalone function nor as an
- * option to CreateProcess.
- *
- * It tries to return an absolute filename.
- *
- * Furthermore, it tries to follow the semantics that cmd.exe, with this
- * exception that PATHEXT environment variable isn't used. Since CreateProcess
- * can start only .com and .exe files, only those extensions are tried. This
- * behavior equals that of msvcrt's spawn functions.
- *
- * - Do not search the path if the filename already contains a path (either
- *   relative or absolute).
- *
- * - If there's really only a filename, check the current directory for file,
- *   then search all path directories.
- *
- * - If filename specified has *any* extension, search for the file with the
- *   specified extension first.
- *
- * - If the literal filename is not found in a directory, try *appending*
- *   (not replacing) .com first and then .exe.
- *
- * - The path variable may contain relative paths; relative paths are relative
- *   to the cwd.
- *
- * - Directories in path may or may not end with a trailing backslash.
- *
- * - CMD does not trim leading/trailing whitespace from path/pathex entries
- *   nor from the environment variables as a whole.
- *
- * - When cmd.exe cannot read a directory, it will just skip it and go on
- *   searching. However, unlike posix-y systems, it will happily try to run a
- *   file that is not readable/executable; if the spawn fails it will not
- *   continue searching.
- *
- * UNC path support: we are dealing with UNC paths in both the path and the
- * filename. This is a deviation from what cmd.exe does (it does not let you
- * start a program by specifying an UNC path on the command line) but this is
- * really a pointless restriction.
- *
- */
-static WCHAR* search_path(const WCHAR *file,
-                            WCHAR *cwd,
-                            const WCHAR *path) {
-  int file_has_dir;
-  WCHAR* result = NULL;
-  WCHAR *file_name_start;
-  WCHAR *dot;
-  const WCHAR *dir_start, *dir_end, *dir_path;
-  size_t dir_len;
-  int name_has_ext;
-
-  size_t file_len = wcslen(file);
-  size_t cwd_len = wcslen(cwd);
-
-  /* If the caller supplies an empty filename,
-   * we're not gonna return c:\windows\.exe -- GFY!
-   */
-  if (file_len == 0
-      || (file_len == 1 && file[0] == L'.')) {
-    return NULL;
-  }
-
-  /* Find the start of the filename so we can split the directory from the
-   * name. */
-  for (file_name_start = (WCHAR*)file + file_len;
-       file_name_start > file
-           && file_name_start[-1] != L'\\'
-           && file_name_start[-1] != L'/'
-           && file_name_start[-1] != L':';
-       file_name_start--);
-
-  file_has_dir = file_name_start != file;
-
-  /* Check if the filename includes an extension */
-  dot = wcschr(file_name_start, L'.');
-  name_has_ext = (dot != NULL && dot[1] != L'\0');
-
-  if (file_has_dir) {
-    /* The file has a path inside, don't use path */
-    result = path_search_walk_ext(
-        file, file_name_start - file,
-        file_name_start, file_len - (file_name_start - file),
-        cwd, cwd_len,
-        name_has_ext);
-
-  } else {
-    dir_end = path;
-
-    /* The file is really only a name; look in cwd first, then scan path */
-    result = path_search_walk_ext(L"", 0,
-                                  file, file_len,
-                                  cwd, cwd_len,
-                                  name_has_ext);
-
-    while (result == NULL) {
-      if (*dir_end == L'\0') {
-        break;
-      }
-
-      /* Skip the separator that dir_end now points to */
-      if (dir_end != path || *path == L';') {
-        dir_end++;
-      }
-
-      /* Next slice starts just after where the previous one ended */
-      dir_start = dir_end;
-
-      /* If path is quoted, find quote end */
-      if (*dir_start == L'"' || *dir_start == L'\'') {
-        dir_end = wcschr(dir_start + 1, *dir_start);
-        if (dir_end == NULL) {
-          dir_end = wcschr(dir_start, L'\0');
-        }
-      }
-      /* Slice until the next ; or \0 is found */
-      dir_end = wcschr(dir_end, L';');
-      if (dir_end == NULL) {
-        dir_end = wcschr(dir_start, L'\0');
-      }
-
-      /* If the slice is zero-length, don't bother */
-      if (dir_end - dir_start == 0) {
-        continue;
-      }
-
-      dir_path = dir_start;
-      dir_len = dir_end - dir_start;
-
-      /* Adjust if the path is quoted. */
-      if (dir_path[0] == '"' || dir_path[0] == '\'') {
-        ++dir_path;
-        --dir_len;
-      }
-
-      if (dir_path[dir_len - 1] == '"' || dir_path[dir_len - 1] == '\'') {
-        --dir_len;
-      }
-
-      result = path_search_walk_ext(dir_path, dir_len,
-                                    file, file_len,
-                                    cwd, cwd_len,
-                                    name_has_ext);
-    }
-  }
-
-  return result;
-}
-
-
-/*
- * Quotes command line arguments
- * Returns a pointer to the end (next char to be written) of the buffer
- */
-WCHAR* quote_cmd_arg(const WCHAR *source, WCHAR *target) {
-  size_t len = wcslen(source);
-  size_t i;
-  int quote_hit;
-  WCHAR* start;
-
-  if (len == 0) {
-    /* Need double quotation for empty argument */
-    *(target++) = L'"';
-    *(target++) = L'"';
-    return target;
-  }
-
-  if (NULL == wcspbrk(source, L" \t\"")) {
-    /* No quotation needed */
-    wcsncpy(target, source, len);
-    target += len;
-    return target;
-  }
-
-  if (NULL == wcspbrk(source, L"\"\\")) {
-    /*
-     * No embedded double quotes or backlashes, so I can just wrap
-     * quote marks around the whole thing.
-     */
-    *(target++) = L'"';
-    wcsncpy(target, source, len);
-    target += len;
-    *(target++) = L'"';
-    return target;
-  }
-
-  /*
-   * Expected input/output:
-   *   input : hello"world
-   *   output: "hello\"world"
-   *   input : hello""world
-   *   output: "hello\"\"world"
-   *   input : hello\world
-   *   output: hello\world
-   *   input : hello\\world
-   *   output: hello\\world
-   *   input : hello\"world
-   *   output: "hello\\\"world"
-   *   input : hello\\"world
-   *   output: "hello\\\\\"world"
-   *   input : hello world\
-   *   output: "hello world\\"
-   */
-
-  *(target++) = L'"';
-  start = target;
-  quote_hit = 1;
-
-  for (i = len; i > 0; --i) {
-    *(target++) = source[i - 1];
-
-    if (quote_hit && source[i - 1] == L'\\') {
-      *(target++) = L'\\';
-    } else if(source[i - 1] == L'"') {
-      quote_hit = 1;
-      *(target++) = L'\\';
-    } else {
-      quote_hit = 0;
-    }
-  }
-  target[0] = L'\0';
-  wcsrev(start);
-  *(target++) = L'"';
-  return target;
-}
-
-
-int make_program_args(char** args, int verbatim_arguments, WCHAR** dst_ptr) {
-  char** arg;
-  WCHAR* dst = NULL;
-  WCHAR* temp_buffer = NULL;
-  size_t dst_len = 0;
-  size_t temp_buffer_len = 0;
-  WCHAR* pos;
-  int arg_count = 0;
-  int err = 0;
-
-  /* Count the required size. */
-  for (arg = args; *arg; arg++) {
-    DWORD arg_len;
-
-    arg_len = MultiByteToWideChar(CP_UTF8,
-                                  0,
-                                  *arg,
-                                  -1,
-                                  NULL,
-                                  0);
-    if (arg_len == 0) {
-      return GetLastError();
-    }
-
-    dst_len += arg_len;
-
-    if (arg_len > temp_buffer_len)
-      temp_buffer_len = arg_len;
-
-    arg_count++;
-  }
-
-  /* Adjust for potential quotes. Also assume the worst-case scenario that
-   * every character needs escaping, so we need twice as much space. */
-  dst_len = dst_len * 2 + arg_count * 2;
-
-  /* Allocate buffer for the final command line. */
-  dst = (WCHAR*) uv__malloc(dst_len * sizeof(WCHAR));
-  if (dst == NULL) {
-    err = ERROR_OUTOFMEMORY;
-    goto error;
-  }
-
-  /* Allocate temporary working buffer. */
-  temp_buffer = (WCHAR*) uv__malloc(temp_buffer_len * sizeof(WCHAR));
-  if (temp_buffer == NULL) {
-    err = ERROR_OUTOFMEMORY;
-    goto error;
-  }
-
-  pos = dst;
-  for (arg = args; *arg; arg++) {
-    DWORD arg_len;
-
-    /* Convert argument to wide char. */
-    arg_len = MultiByteToWideChar(CP_UTF8,
-                                  0,
-                                  *arg,
-                                  -1,
-                                  temp_buffer,
-                                  (int) (dst + dst_len - pos));
-    if (arg_len == 0) {
-      err = GetLastError();
-      goto error;
-    }
-
-    if (verbatim_arguments) {
-      /* Copy verbatim. */
-      wcscpy(pos, temp_buffer);
-      pos += arg_len - 1;
-    } else {
-      /* Quote/escape, if needed. */
-      pos = quote_cmd_arg(temp_buffer, pos);
-    }
-
-    *pos++ = *(arg + 1) ? L' ' : L'\0';
-  }
-
-  uv__free(temp_buffer);
-
-  *dst_ptr = dst;
-  return 0;
-
-error:
-  uv__free(dst);
-  uv__free(temp_buffer);
-  return err;
-}
-
-
-int env_strncmp(const wchar_t* a, int na, const wchar_t* b) {
-  const wchar_t* a_eq;
-  const wchar_t* b_eq;
-  wchar_t* A;
-  wchar_t* B;
-  int nb;
-  int r;
-
-  if (na < 0) {
-    a_eq = wcschr(a, L'=');
-    assert(a_eq);
-    na = (int)(long)(a_eq - a);
-  } else {
-    na--;
-  }
-  b_eq = wcschr(b, L'=');
-  assert(b_eq);
-  nb = b_eq - b;
-
-  A = (wchar_t*)alloca((na+1) * sizeof(wchar_t));
-  B = (wchar_t*)alloca((nb+1) * sizeof(wchar_t));
-
-  r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, a, na, A, na);
-  assert(r==na);
-  A[na] = L'\0';
-  r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, b, nb, B, nb);
-  assert(r==nb);
-  B[nb] = L'\0';
-
-  while (1) {
-    wchar_t AA = *A++;
-    wchar_t BB = *B++;
-    if (AA < BB) {
-      return -1;
-    } else if (AA > BB) {
-      return 1;
-    } else if (!AA && !BB) {
-      return 0;
-    }
-  }
-}
-
-
-static int qsort_wcscmp(const void *a, const void *b) {
-  wchar_t* astr = *(wchar_t* const*)a;
-  wchar_t* bstr = *(wchar_t* const*)b;
-  return env_strncmp(astr, -1, bstr);
-}
-
-
-/*
- * The way windows takes environment variables is different than what C does;
- * Windows wants a contiguous block of null-terminated strings, terminated
- * with an additional null.
- *
- * Windows has a few "essential" environment variables. winsock will fail
- * to initialize if SYSTEMROOT is not defined; some APIs make reference to
- * TEMP. SYSTEMDRIVE is probably also important. We therefore ensure that
- * these get defined if the input environment block does not contain any
- * values for them.
- *
- * Also add variables known to Cygwin to be required for correct
- * subprocess operation in many cases:
- * https://github.com/Alexpux/Cygwin/blob/b266b04fbbd3a595f02ea149e4306d3ab9b1fe3d/winsup/cygwin/environ.cc#L955
- *
- */
-int make_program_env(char* env_block[], WCHAR** dst_ptr) {
-  WCHAR* dst;
-  WCHAR* ptr;
-  char** env;
-  size_t env_len = 0;
-  int len;
-  size_t i;
-  DWORD var_size;
-  size_t env_block_count = 1; /* 1 for null-terminator */
-  WCHAR* dst_copy;
-  WCHAR** ptr_copy;
-  WCHAR** env_copy;
-  DWORD* required_vars_value_len =
-      (DWORD*)alloca(n_required_vars * sizeof(DWORD*));
-
-  /* first pass: determine size in UTF-16 */
-  for (env = env_block; *env; env++) {
-    int len;
-    if (strchr(*env, '=')) {
-      len = MultiByteToWideChar(CP_UTF8,
-                                0,
-                                *env,
-                                -1,
-                                NULL,
-                                0);
-      if (len <= 0) {
-        return GetLastError();
-      }
-      env_len += len;
-      env_block_count++;
-    }
-  }
-
-  /* second pass: copy to UTF-16 environment block */
-  dst_copy = (WCHAR*)uv__malloc(env_len * sizeof(WCHAR));
-  if (!dst_copy) {
-    return ERROR_OUTOFMEMORY;
-  }
-  env_copy = (WCHAR**)alloca(env_block_count * sizeof(WCHAR*));
-
-  ptr = dst_copy;
-  ptr_copy = env_copy;
-  for (env = env_block; *env; env++) {
-    if (strchr(*env, '=')) {
-      len = MultiByteToWideChar(CP_UTF8,
-                                0,
-                                *env,
-                                -1,
-                                ptr,
-                                (int) (env_len - (ptr - dst_copy)));
-      if (len <= 0) {
-        DWORD err = GetLastError();
-        uv__free(dst_copy);
-        return err;
-      }
-      *ptr_copy++ = ptr;
-      ptr += len;
-    }
-  }
-  *ptr_copy = NULL;
-  assert(env_len == (size_t) (ptr - dst_copy));
-
-  /* sort our (UTF-16) copy */
-  qsort(env_copy, env_block_count-1, sizeof(wchar_t*), qsort_wcscmp);
-
-  /* third pass: check for required variables */
-  for (ptr_copy = env_copy, i = 0; i < n_required_vars; ) {
-    int cmp;
-    if (!*ptr_copy) {
-      cmp = -1;
-    } else {
-      cmp = env_strncmp(required_vars[i].wide_eq,
-                       required_vars[i].len,
-                        *ptr_copy);
-    }
-    if (cmp < 0) {
-      /* missing required var */
-      var_size = GetEnvironmentVariableW(required_vars[i].wide, NULL, 0);
-      required_vars_value_len[i] = var_size;
-      if (var_size != 0) {
-        env_len += required_vars[i].len;
-        env_len += var_size;
-      }
-      i++;
-    } else {
-      ptr_copy++;
-      if (cmp == 0)
-        i++;
-    }
-  }
-
-  /* final pass: copy, in sort order, and inserting required variables */
-  dst = (WCHAR*)uv__malloc((1+env_len) * sizeof(WCHAR));
-  if (!dst) {
-    uv__free(dst_copy);
-    return ERROR_OUTOFMEMORY;
-  }
-
-  for (ptr = dst, ptr_copy = env_copy, i = 0;
-       *ptr_copy || i < n_required_vars;
-       ptr += len) {
-    int cmp;
-    if (i >= n_required_vars) {
-      cmp = 1;
-    } else if (!*ptr_copy) {
-      cmp = -1;
-    } else {
-      cmp = env_strncmp(required_vars[i].wide_eq,
-                        required_vars[i].len,
-                        *ptr_copy);
-    }
-    if (cmp < 0) {
-      /* missing required var */
-      len = required_vars_value_len[i];
-      if (len) {
-        wcscpy(ptr, required_vars[i].wide_eq);
-        ptr += required_vars[i].len;
-        var_size = GetEnvironmentVariableW(required_vars[i].wide,
-                                           ptr,
-                                           (int) (env_len - (ptr - dst)));
-        if (var_size != (DWORD) (len - 1)) { /* TODO: handle race condition? */
-          uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
-        }
-      }
-      i++;
-    } else {
-      /* copy var from env_block */
-      len = wcslen(*ptr_copy) + 1;
-      wmemcpy(ptr, *ptr_copy, len);
-      ptr_copy++;
-      if (cmp == 0)
-        i++;
-    }
-  }
-
-  /* Terminate with an extra NULL. */
-  assert(env_len == (size_t) (ptr - dst));
-  *ptr = L'\0';
-
-  uv__free(dst_copy);
-  *dst_ptr = dst;
-  return 0;
-}
-
-/*
- * Attempt to find the value of the PATH environment variable in the child's
- * preprocessed environment.
- *
- * If found, a pointer into `env` is returned. If not found, NULL is returned.
- */
-static WCHAR* find_path(WCHAR *env) {
-  for (; env != NULL && *env != 0; env += wcslen(env) + 1) {
-    if ((env[0] == L'P' || env[0] == L'p') &&
-        (env[1] == L'A' || env[1] == L'a') &&
-        (env[2] == L'T' || env[2] == L't') &&
-        (env[3] == L'H' || env[3] == L'h') &&
-        (env[4] == L'=')) {
-      return &env[5];
-    }
-  }
-
-  return NULL;
-}
-
-/*
- * Called on Windows thread-pool thread to indicate that
- * a child process has exited.
- */
-static void CALLBACK exit_wait_callback(void* data, BOOLEAN didTimeout) {
-  uv_process_t* process = (uv_process_t*) data;
-  uv_loop_t* loop = process->loop;
-
-  assert(didTimeout == FALSE);
-  assert(process);
-  assert(!process->exit_cb_pending);
-
-  process->exit_cb_pending = 1;
-
-  /* Post completed */
-  POST_COMPLETION_FOR_REQ(loop, &process->exit_req);
-}
-
-
-/* Called on main thread after a child process has exited. */
-void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
-  int64_t exit_code;
-  DWORD status;
-
-  assert(handle->exit_cb_pending);
-  handle->exit_cb_pending = 0;
-
-  /* If we're closing, don't call the exit callback. Just schedule a close
-   * callback now. */
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-    return;
-  }
-
-  /* Unregister from process notification. */
-  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
-    UnregisterWait(handle->wait_handle);
-    handle->wait_handle = INVALID_HANDLE_VALUE;
-  }
-
-  /* Set the handle to inactive: no callbacks will be made after the exit
-   * callback. */
-  uv__handle_stop(handle);
-
-  if (GetExitCodeProcess(handle->process_handle, &status)) {
-    exit_code = status;
-  } else {
-    /* Unable to obtain the exit code. This should never happen. */
-    exit_code = uv_translate_sys_error(GetLastError());
-  }
-
-  /* Fire the exit callback. */
-  if (handle->exit_cb) {
-    handle->exit_cb(handle, exit_code, handle->exit_signal);
-  }
-}
-
-
-void uv_process_close(uv_loop_t* loop, uv_process_t* handle) {
-  uv__handle_closing(handle);
-
-  if (handle->wait_handle != INVALID_HANDLE_VALUE) {
-    /* This blocks until either the wait was cancelled, or the callback has
-     * completed. */
-    BOOL r = UnregisterWaitEx(handle->wait_handle, INVALID_HANDLE_VALUE);
-    if (!r) {
-      /* This should never happen, and if it happens, we can't recover... */
-      uv_fatal_error(GetLastError(), "UnregisterWaitEx");
-    }
-
-    handle->wait_handle = INVALID_HANDLE_VALUE;
-  }
-
-  if (!handle->exit_cb_pending) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-}
-
-
-void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) {
-  assert(!handle->exit_cb_pending);
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-  /* Clean-up the process handle. */
-  CloseHandle(handle->process_handle);
-
-  uv__handle_close(handle);
-}
-
-
-int uv_spawn(uv_loop_t* loop,
-             uv_process_t* process,
-             const uv_process_options_t* options) {
-  int i;
-  int err = 0;
-  WCHAR* path = NULL, *alloc_path = NULL;
-  BOOL result;
-  WCHAR* application_path = NULL, *application = NULL, *arguments = NULL,
-         *env = NULL, *cwd = NULL;
-  STARTUPINFOW startup;
-  PROCESS_INFORMATION info;
-  DWORD process_flags;
-
-  uv_process_init(loop, process);
-  process->exit_cb = options->exit_cb;
-
-  if (options->flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) {
-    return UV_ENOTSUP;
-  }
-
-  if (options->file == NULL ||
-      options->args == NULL) {
-    return UV_EINVAL;
-  }
-
-  assert(options->file != NULL);
-  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
-                              UV_PROCESS_SETGID |
-                              UV_PROCESS_SETUID |
-                              UV_PROCESS_WINDOWS_HIDE |
-                              UV_PROCESS_WINDOWS_HIDE_CONSOLE |
-                              UV_PROCESS_WINDOWS_HIDE_GUI |
-                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
-
-  err = uv_utf8_to_utf16_alloc(options->file, &application);
-  if (err)
-    goto done;
-
-  err = make_program_args(
-      options->args,
-      options->flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
-      &arguments);
-  if (err)
-    goto done;
-
-  if (options->env) {
-     err = make_program_env(options->env, &env);
-     if (err)
-       goto done;
-  }
-
-  if (options->cwd) {
-    /* Explicit cwd */
-    err = uv_utf8_to_utf16_alloc(options->cwd, &cwd);
-    if (err)
-      goto done;
-
-  } else {
-    /* Inherit cwd */
-    DWORD cwd_len, r;
-
-    cwd_len = GetCurrentDirectoryW(0, NULL);
-    if (!cwd_len) {
-      err = GetLastError();
-      goto done;
-    }
-
-    cwd = (WCHAR*) uv__malloc(cwd_len * sizeof(WCHAR));
-    if (cwd == NULL) {
-      err = ERROR_OUTOFMEMORY;
-      goto done;
-    }
-
-    r = GetCurrentDirectoryW(cwd_len, cwd);
-    if (r == 0 || r >= cwd_len) {
-      err = GetLastError();
-      goto done;
-    }
-  }
-
-  /* Get PATH environment variable. */
-  path = find_path(env);
-  if (path == NULL) {
-    DWORD path_len, r;
-
-    path_len = GetEnvironmentVariableW(L"PATH", NULL, 0);
-    if (path_len == 0) {
-      err = GetLastError();
-      goto done;
-    }
-
-    alloc_path = (WCHAR*) uv__malloc(path_len * sizeof(WCHAR));
-    if (alloc_path == NULL) {
-      err = ERROR_OUTOFMEMORY;
-      goto done;
-    }
-    path = alloc_path;
-
-    r = GetEnvironmentVariableW(L"PATH", path, path_len);
-    if (r == 0 || r >= path_len) {
-      err = GetLastError();
-      goto done;
-    }
-  }
-
-  err = uv__stdio_create(loop, options, &process->child_stdio_buffer);
-  if (err)
-    goto done;
-
-  application_path = search_path(application,
-                                 cwd,
-                                 path);
-  if (application_path == NULL) {
-    /* Not found. */
-    err = ERROR_FILE_NOT_FOUND;
-    goto done;
-  }
-
-  startup.cb = sizeof(startup);
-  startup.lpReserved = NULL;
-  startup.lpDesktop = NULL;
-  startup.lpTitle = NULL;
-  startup.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-
-  startup.cbReserved2 = uv__stdio_size(process->child_stdio_buffer);
-  startup.lpReserved2 = (BYTE*) process->child_stdio_buffer;
-
-  startup.hStdInput = uv__stdio_handle(process->child_stdio_buffer, 0);
-  startup.hStdOutput = uv__stdio_handle(process->child_stdio_buffer, 1);
-  startup.hStdError = uv__stdio_handle(process->child_stdio_buffer, 2);
-
-  process_flags = CREATE_UNICODE_ENVIRONMENT;
-
-  if ((options->flags & UV_PROCESS_WINDOWS_HIDE_CONSOLE) ||
-      (options->flags & UV_PROCESS_WINDOWS_HIDE)) {
-    /* Avoid creating console window if stdio is not inherited. */
-    for (i = 0; i < options->stdio_count; i++) {
-      if (options->stdio[i].flags & UV_INHERIT_FD)
-        break;
-      if (i == options->stdio_count - 1)
-        process_flags |= CREATE_NO_WINDOW;
-    }
-  }
-  if ((options->flags & UV_PROCESS_WINDOWS_HIDE_GUI) ||
-      (options->flags & UV_PROCESS_WINDOWS_HIDE)) {
-    /* Use SW_HIDE to avoid any potential process window. */
-    startup.wShowWindow = SW_HIDE;
-  } else {
-    startup.wShowWindow = SW_SHOWDEFAULT;
-  }
-
-  if (options->flags & UV_PROCESS_DETACHED) {
-    /* Note that we're not setting the CREATE_BREAKAWAY_FROM_JOB flag. That
-     * means that libuv might not let you create a fully daemonized process
-     * when run under job control. However the type of job control that libuv
-     * itself creates doesn't trickle down to subprocesses so they can still
-     * daemonize.
-     *
-     * A reason to not do this is that CREATE_BREAKAWAY_FROM_JOB makes the
-     * CreateProcess call fail if we're under job control that doesn't allow
-     * breakaway.
-     */
-    process_flags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;
-  }
-
-  if (!CreateProcessW(application_path,
-                     arguments,
-                     NULL,
-                     NULL,
-                     1,
-                     process_flags,
-                     env,
-                     cwd,
-                     &startup,
-                     &info)) {
-    /* CreateProcessW failed. */
-    err = GetLastError();
-    goto done;
-  }
-
-  /* Spawn succeeded. Beyond this point, failure is reported asynchronously. */
-
-  process->process_handle = info.hProcess;
-  process->pid = info.dwProcessId;
-
-  /* If the process isn't spawned as detached, assign to the global job object
-   * so windows will kill it when the parent process dies. */
-  if (!(options->flags & UV_PROCESS_DETACHED)) {
-    uv_once(&uv_global_job_handle_init_guard_, uv__init_global_job_handle);
-
-    if (!AssignProcessToJobObject(uv_global_job_handle_, info.hProcess)) {
-      /* AssignProcessToJobObject might fail if this process is under job
-       * control and the job doesn't have the
-       * JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK flag set, on a Windows version
-       * that doesn't support nested jobs.
-       *
-       * When that happens we just swallow the error and continue without
-       * establishing a kill-child-on-parent-exit relationship, otherwise
-       * there would be no way for libuv applications run under job control
-       * to spawn processes at all.
-       */
-      DWORD err = GetLastError();
-      if (err != ERROR_ACCESS_DENIED)
-        uv_fatal_error(err, "AssignProcessToJobObject");
-    }
-  }
-
-  /* Set IPC pid to all IPC pipes. */
-  for (i = 0; i < options->stdio_count; i++) {
-    const uv_stdio_container_t* fdopt = &options->stdio[i];
-    if (fdopt->flags & UV_CREATE_PIPE &&
-        fdopt->data.stream->type == UV_NAMED_PIPE &&
-        ((uv_pipe_t*) fdopt->data.stream)->ipc) {
-      ((uv_pipe_t*) fdopt->data.stream)->pipe.conn.ipc_remote_pid =
-          info.dwProcessId;
-    }
-  }
-
-  /* Setup notifications for when the child process exits. */
-  result = RegisterWaitForSingleObject(&process->wait_handle,
-      process->process_handle, exit_wait_callback, (void*)process, INFINITE,
-      WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
-  if (!result) {
-    uv_fatal_error(GetLastError(), "RegisterWaitForSingleObject");
-  }
-
-  CloseHandle(info.hThread);
-
-  assert(!err);
-
-  /* Make the handle active. It will remain active until the exit callback is
-   * made or the handle is closed, whichever happens first. */
-  uv__handle_start(process);
-
-  /* Cleanup, whether we succeeded or failed. */
- done:
-  uv__free(application);
-  uv__free(application_path);
-  uv__free(arguments);
-  uv__free(cwd);
-  uv__free(env);
-  uv__free(alloc_path);
-
-  if (process->child_stdio_buffer != NULL) {
-    /* Clean up child stdio handles. */
-    uv__stdio_destroy(process->child_stdio_buffer);
-    process->child_stdio_buffer = NULL;
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-static int uv__kill(HANDLE process_handle, int signum) {
-  if (signum < 0 || signum >= NSIG) {
-    return UV_EINVAL;
-  }
-
-  switch (signum) {
-    case SIGTERM:
-    case SIGKILL:
-    case SIGINT: {
-      /* Unconditionally terminate the process. On Windows, killed processes
-       * normally return 1. */
-      DWORD status;
-      int err;
-
-      if (TerminateProcess(process_handle, 1))
-        return 0;
-
-      /* If the process already exited before TerminateProcess was called,.
-       * TerminateProcess will fail with ERROR_ACCESS_DENIED. */
-      err = GetLastError();
-      if (err == ERROR_ACCESS_DENIED &&
-          GetExitCodeProcess(process_handle, &status) &&
-          status != STILL_ACTIVE) {
-        return UV_ESRCH;
-      }
-
-      return uv_translate_sys_error(err);
-    }
-
-    case 0: {
-      /* Health check: is the process still alive? */
-      DWORD status;
-
-      if (!GetExitCodeProcess(process_handle, &status))
-        return uv_translate_sys_error(GetLastError());
-
-      if (status != STILL_ACTIVE)
-        return UV_ESRCH;
-
-      return 0;
-    }
-
-    default:
-      /* Unsupported signal. */
-      return UV_ENOSYS;
-  }
-}
-
-
-int uv_process_kill(uv_process_t* process, int signum) {
-  int err;
-
-  if (process->process_handle == INVALID_HANDLE_VALUE) {
-    return UV_EINVAL;
-  }
-
-  err = uv__kill(process->process_handle, signum);
-  if (err) {
-    return err;  /* err is already translated. */
-  }
-
-  process->exit_signal = signum;
-
-  return 0;
-}
-
-
-int uv_kill(int pid, int signum) {
-  int err;
-  HANDLE process_handle;
-
-  if (pid == 0) {
-    process_handle = GetCurrentProcess();
-  } else {
-    process_handle = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION,
-                                 FALSE,
-                                 pid);
-  }
-
-  if (process_handle == NULL) {
-    err = GetLastError();
-    if (err == ERROR_INVALID_PARAMETER) {
-      return UV_ESRCH;
-    } else {
-      return uv_translate_sys_error(err);
-    }
-  }
-
-  err = uv__kill(process_handle, signum);
-  CloseHandle(process_handle);
-
-  return err;  /* err is already translated. */
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/req-inl.h b/wpiutil/src/main/native/libuv/src/win/req-inl.h
deleted file mode 100644
index f2513b7..0000000
--- a/wpiutil/src/main/native/libuv/src/win/req-inl.h
+++ /dev/null
@@ -1,221 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_REQ_INL_H_
-#define UV_WIN_REQ_INL_H_
-
-#include <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-#define SET_REQ_STATUS(req, status)                                     \
-   (req)->u.io.overlapped.Internal = (ULONG_PTR) (status)
-
-#define SET_REQ_ERROR(req, error)                                       \
-  SET_REQ_STATUS((req), NTSTATUS_FROM_WIN32((error)))
-
-/* Note: used open-coded in UV_REQ_INIT() because of a circular dependency
- * between src/uv-common.h and src/win/internal.h.
- */
-#define SET_REQ_SUCCESS(req)                                            \
-  SET_REQ_STATUS((req), STATUS_SUCCESS)
-
-#define GET_REQ_STATUS(req)                                             \
-  ((NTSTATUS) (req)->u.io.overlapped.Internal)
-
-#define REQ_SUCCESS(req)                                                \
-  (NT_SUCCESS(GET_REQ_STATUS((req))))
-
-#define GET_REQ_ERROR(req)                                              \
-  (pRtlNtStatusToDosError(GET_REQ_STATUS((req))))
-
-#define GET_REQ_SOCK_ERROR(req)                                         \
-  (uv_ntstatus_to_winsock_error(GET_REQ_STATUS((req))))
-
-
-#define REGISTER_HANDLE_REQ(loop, handle, req)                          \
-  do {                                                                  \
-    INCREASE_ACTIVE_COUNT((loop), (handle));                            \
-    uv__req_register((loop), (req));                                    \
-  } while (0)
-
-#define UNREGISTER_HANDLE_REQ(loop, handle, req)                        \
-  do {                                                                  \
-    DECREASE_ACTIVE_COUNT((loop), (handle));                            \
-    uv__req_unregister((loop), (req));                                  \
-  } while (0)
-
-
-#define UV_SUCCEEDED_WITHOUT_IOCP(result)                               \
-  ((result) && (handle->flags & UV_HANDLE_SYNC_BYPASS_IOCP))
-
-#define UV_SUCCEEDED_WITH_IOCP(result)                                  \
-  ((result) || (GetLastError() == ERROR_IO_PENDING))
-
-
-#define POST_COMPLETION_FOR_REQ(loop, req)                              \
-  if (!PostQueuedCompletionStatus((loop)->iocp,                         \
-                                  0,                                    \
-                                  0,                                    \
-                                  &((req)->u.io.overlapped))) {         \
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");       \
-  }
-
-
-INLINE static uv_req_t* uv_overlapped_to_req(OVERLAPPED* overlapped) {
-  return CONTAINING_RECORD(overlapped, uv_req_t, u.io.overlapped);
-}
-
-
-INLINE static void uv_insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
-  req->next_req = NULL;
-  if (loop->pending_reqs_tail) {
-#ifdef _DEBUG
-    /* Ensure the request is not already in the queue, or the queue
-     * will get corrupted.
-     */
-    uv_req_t* current = loop->pending_reqs_tail;
-    do {
-      assert(req != current);
-      current = current->next_req;
-    } while(current != loop->pending_reqs_tail);
-#endif
-
-    req->next_req = loop->pending_reqs_tail->next_req;
-    loop->pending_reqs_tail->next_req = req;
-    loop->pending_reqs_tail = req;
-  } else {
-    req->next_req = req;
-    loop->pending_reqs_tail = req;
-  }
-}
-
-
-#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
-  do {                                                                        \
-    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
-      case UV_TCP:                                                            \
-        uv_process_tcp_##method##_req(loop,                                   \
-                                      (uv_tcp_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      case UV_NAMED_PIPE:                                                     \
-        uv_process_pipe_##method##_req(loop,                                  \
-                                       (uv_pipe_t*) ((req)->handle_at),       \
-                                       req);                                  \
-        break;                                                                \
-                                                                              \
-      case UV_TTY:                                                            \
-        uv_process_tty_##method##_req(loop,                                   \
-                                      (uv_tty_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      default:                                                                \
-        assert(0);                                                            \
-    }                                                                         \
-  } while (0)
-
-
-INLINE static int uv_process_reqs(uv_loop_t* loop) {
-  uv_req_t* req;
-  uv_req_t* first;
-  uv_req_t* next;
-
-  if (loop->pending_reqs_tail == NULL)
-    return 0;
-
-  first = loop->pending_reqs_tail->next_req;
-  next = first;
-  loop->pending_reqs_tail = NULL;
-
-  while (next != NULL) {
-    req = next;
-    next = req->next_req != first ? req->next_req : NULL;
-
-    switch (req->type) {
-      case UV_READ:
-        DELEGATE_STREAM_REQ(loop, req, read, data);
-        break;
-
-      case UV_WRITE:
-        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
-        break;
-
-      case UV_ACCEPT:
-        DELEGATE_STREAM_REQ(loop, req, accept, data);
-        break;
-
-      case UV_CONNECT:
-        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
-        break;
-
-      case UV_SHUTDOWN:
-        /* Tcp shutdown requests don't come here. */
-        assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
-        uv_process_pipe_shutdown_req(
-            loop,
-            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle,
-            (uv_shutdown_t*) req);
-        break;
-
-      case UV_UDP_RECV:
-        uv_process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
-        break;
-
-      case UV_UDP_SEND:
-        uv_process_udp_send_req(loop,
-                                ((uv_udp_send_t*) req)->handle,
-                                (uv_udp_send_t*) req);
-        break;
-
-      case UV_WAKEUP:
-        uv_process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
-        break;
-
-      case UV_SIGNAL_REQ:
-        uv_process_signal_req(loop, (uv_signal_t*) req->data, req);
-        break;
-
-      case UV_POLL_REQ:
-        uv_process_poll_req(loop, (uv_poll_t*) req->data, req);
-        break;
-
-      case UV_PROCESS_EXIT:
-        uv_process_proc_exit(loop, (uv_process_t*) req->data);
-        break;
-
-      case UV_FS_EVENT_REQ:
-        uv_process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
-        break;
-
-      default:
-        assert(0);
-    }
-  }
-
-  return 1;
-}
-
-#endif /* UV_WIN_REQ_INL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/signal.cpp b/wpiutil/src/main/native/libuv/src/win/signal.cpp
deleted file mode 100644
index 276dc60..0000000
--- a/wpiutil/src/main/native/libuv/src/win/signal.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- * 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 <assert.h>
-#include <signal.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-RB_HEAD(uv_signal_tree_s, uv_signal_s);
-
-static struct uv_signal_tree_s uv__signal_tree = RB_INITIALIZER(uv__signal_tree);
-static CRITICAL_SECTION uv__signal_lock;
-
-static BOOL WINAPI uv__signal_control_handler(DWORD type);
-
-int uv__signal_start(uv_signal_t* handle,
-                     uv_signal_cb signal_cb,
-                     int signum,
-                     int oneshot);
-
-void uv_signals_init(void) {
-  InitializeCriticalSection(&uv__signal_lock);
-  if (!SetConsoleCtrlHandler(uv__signal_control_handler, TRUE))
-    abort();
-}
-
-
-static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
-  /* Compare signums first so all watchers with the same signnum end up
-   * adjacent. */
-  if (w1->signum < w2->signum) return -1;
-  if (w1->signum > w2->signum) return 1;
-
-  /* Sort by loop pointer, so we can easily look up the first item after
-   * { .signum = x, .loop = NULL }. */
-  if ((uintptr_t) w1->loop < (uintptr_t) w2->loop) return -1;
-  if ((uintptr_t) w1->loop > (uintptr_t) w2->loop) return 1;
-
-  if ((uintptr_t) w1 < (uintptr_t) w2) return -1;
-  if ((uintptr_t) w1 > (uintptr_t) w2) return 1;
-
-  return 0;
-}
-
-
-RB_GENERATE_STATIC(uv_signal_tree_s, uv_signal_s, tree_entry, uv__signal_compare)
-
-
-/*
- * Dispatches signal {signum} to all active uv_signal_t watchers in all loops.
- * Returns 1 if the signal was dispatched to any watcher, or 0 if there were
- * no active signal watchers observing this signal.
- */
-int uv__signal_dispatch(int signum) {
-  uv_signal_t lookup;
-  uv_signal_t* handle;
-  int dispatched;
-
-  dispatched = 0;
-
-  EnterCriticalSection(&uv__signal_lock);
-
-  lookup.signum = signum;
-  lookup.loop = NULL;
-
-  for (handle = RB_NFIND(uv_signal_tree_s, &uv__signal_tree, &lookup);
-       handle != NULL && handle->signum == signum;
-       handle = RB_NEXT(uv_signal_tree_s, &uv__signal_tree, handle)) {
-    unsigned long previous = InterlockedExchange(
-            (volatile LONG*) &handle->pending_signum, signum);
-
-    if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
-      continue;
-
-    if (!previous) {
-      POST_COMPLETION_FOR_REQ(handle->loop, &handle->signal_req);
-    }
-
-    dispatched = 1;
-    if (handle->flags & UV_SIGNAL_ONE_SHOT)
-      handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
-  }
-
-  LeaveCriticalSection(&uv__signal_lock);
-
-  return dispatched;
-}
-
-
-static BOOL WINAPI uv__signal_control_handler(DWORD type) {
-  switch (type) {
-    case CTRL_C_EVENT:
-      return uv__signal_dispatch(SIGINT);
-
-    case CTRL_BREAK_EVENT:
-      return uv__signal_dispatch(SIGBREAK);
-
-    case CTRL_CLOSE_EVENT:
-      if (uv__signal_dispatch(SIGHUP)) {
-        /* Windows will terminate the process after the control handler
-         * returns. After that it will just terminate our process. Therefore
-         * block the signal handler so the main loop has some time to pick up
-         * the signal and do something for a few seconds. */
-        Sleep(INFINITE);
-        return TRUE;
-      }
-      return FALSE;
-
-    case CTRL_LOGOFF_EVENT:
-    case CTRL_SHUTDOWN_EVENT:
-      /* These signals are only sent to services. Services have their own
-       * notification mechanism, so there's no point in handling these. */
-
-    default:
-      /* We don't handle these. */
-      return FALSE;
-  }
-}
-
-
-int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
-  handle->pending_signum = 0;
-  handle->signum = 0;
-  handle->signal_cb = NULL;
-
-  UV_REQ_INIT(&handle->signal_req, UV_SIGNAL_REQ);
-  handle->signal_req.data = handle;
-
-  return 0;
-}
-
-
-int uv_signal_stop(uv_signal_t* handle) {
-  uv_signal_t* removed_handle;
-
-  /* If the watcher wasn't started, this is a no-op. */
-  if (handle->signum == 0)
-    return 0;
-
-  EnterCriticalSection(&uv__signal_lock);
-
-  removed_handle = RB_REMOVE(uv_signal_tree_s, &uv__signal_tree, handle);
-  assert(removed_handle == handle);
-
-  LeaveCriticalSection(&uv__signal_lock);
-
-  handle->signum = 0;
-  uv__handle_stop(handle);
-
-  return 0;
-}
-
-
-int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) {
-  return uv__signal_start(handle, signal_cb, signum, 0);
-}
-
-
-int uv_signal_start_oneshot(uv_signal_t* handle,
-                            uv_signal_cb signal_cb,
-                            int signum) {
-  return uv__signal_start(handle, signal_cb, signum, 1);
-}
-
-
-int uv__signal_start(uv_signal_t* handle,
-                            uv_signal_cb signal_cb,
-                            int signum,
-                            int oneshot) {
-  /* Test for invalid signal values. */
-  if (signum <= 0 || signum >= NSIG)
-    return UV_EINVAL;
-
-  /* Short circuit: if the signal watcher is already watching {signum} don't go
-   * through the process of deregistering and registering the handler.
-   * Additionally, this avoids pending signals getting lost in the (small) time
-   * frame that handle->signum == 0. */
-  if (signum == handle->signum) {
-    handle->signal_cb = signal_cb;
-    return 0;
-  }
-
-  /* If the signal handler was already active, stop it first. */
-  if (handle->signum != 0) {
-    int r = uv_signal_stop(handle);
-    /* uv_signal_stop is infallible. */
-    assert(r == 0);
-  }
-
-  EnterCriticalSection(&uv__signal_lock);
-
-  handle->signum = signum;
-  if (oneshot)
-    handle->flags |= UV_SIGNAL_ONE_SHOT;
-
-  RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);
-
-  LeaveCriticalSection(&uv__signal_lock);
-
-  handle->signal_cb = signal_cb;
-  uv__handle_start(handle);
-
-  return 0;
-}
-
-
-void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
-    uv_req_t* req) {
-  long dispatched_signum;
-
-  assert(handle->type == UV_SIGNAL);
-  assert(req->type == UV_SIGNAL_REQ);
-
-  dispatched_signum = InterlockedExchange(
-          (volatile LONG*) &handle->pending_signum, 0);
-  assert(dispatched_signum != 0);
-
-  /* Check if the pending signal equals the signum that we are watching for.
-   * These can get out of sync when the handler is stopped and restarted while
-   * the signal_req is pending. */
-  if (dispatched_signum == handle->signum)
-    handle->signal_cb(handle, dispatched_signum);
-
-  if (handle->flags & UV_SIGNAL_ONE_SHOT)
-    uv_signal_stop(handle);
-
-  if (handle->flags & UV_HANDLE_CLOSING) {
-    /* When it is closing, it must be stopped at this point. */
-    assert(handle->signum == 0);
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-}
-
-
-void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle) {
-  uv_signal_stop(handle);
-  uv__handle_closing(handle);
-
-  if (handle->pending_signum == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-}
-
-
-void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle) {
-  assert(handle->flags & UV_HANDLE_CLOSING);
-  assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-  assert(handle->signum == 0);
-  assert(handle->pending_signum == 0);
-
-  handle->flags |= UV_HANDLE_CLOSED;
-
-  uv__handle_close(handle);
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/snprintf.cpp b/wpiutil/src/main/native/libuv/src/win/snprintf.cpp
deleted file mode 100644
index 776c0e3..0000000
--- a/wpiutil/src/main/native/libuv/src/win/snprintf.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright the libuv project contributors. All rights reserved.
- *
- * 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.
- */
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-
-#include <stdio.h>
-#include <stdarg.h>
-
-/* Emulate snprintf() on MSVC<2015, _snprintf() doesn't zero-terminate the buffer
- * on overflow...
- */
-int snprintf(char* buf, size_t len, const char* fmt, ...) {
-  int n;
-  va_list ap;
-  va_start(ap, fmt);
-
-  n = _vscprintf(fmt, ap);
-  vsnprintf_s(buf, len, _TRUNCATE, fmt, ap);
-
-  va_end(ap);
-  return n;
-}
-
-#endif
diff --git a/wpiutil/src/main/native/libuv/src/win/stream-inl.h b/wpiutil/src/main/native/libuv/src/win/stream-inl.h
deleted file mode 100644
index 40f5ddd..0000000
--- a/wpiutil/src/main/native/libuv/src/win/stream-inl.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_STREAM_INL_H_
-#define UV_WIN_STREAM_INL_H_
-
-#include <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-INLINE static void uv_stream_init(uv_loop_t* loop,
-                                  uv_stream_t* handle,
-                                  uv_handle_type type) {
-  uv__handle_init(loop, (uv_handle_t*) handle, type);
-  handle->write_queue_size = 0;
-  handle->activecnt = 0;
-  handle->stream.conn.shutdown_req = NULL;
-  handle->stream.conn.write_reqs_pending = 0;
-
-  UV_REQ_INIT(&handle->read_req, UV_READ);
-  handle->read_req.event_handle = NULL;
-  handle->read_req.wait_handle = INVALID_HANDLE_VALUE;
-  handle->read_req.data = handle;
-}
-
-
-INLINE static void uv_connection_init(uv_stream_t* handle) {
-  handle->flags |= UV_HANDLE_CONNECTION;
-}
-
-
-#endif /* UV_WIN_STREAM_INL_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/stream.cpp b/wpiutil/src/main/native/libuv/src/win/stream.cpp
deleted file mode 100644
index 7656627..0000000
--- a/wpiutil/src/main/native/libuv/src/win/stream.cpp
+++ /dev/null
@@ -1,240 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "req-inl.h"
-
-
-int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
-  int err;
-
-  err = ERROR_INVALID_PARAMETER;
-  switch (stream->type) {
-    case UV_TCP:
-      err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
-      break;
-    case UV_NAMED_PIPE:
-      err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
-      break;
-    default:
-      assert(0);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_accept(uv_stream_t* server, uv_stream_t* client) {
-  int err;
-
-  err = ERROR_INVALID_PARAMETER;
-  switch (server->type) {
-    case UV_TCP:
-      err = uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
-      break;
-    case UV_NAMED_PIPE:
-      err = uv_pipe_accept((uv_pipe_t*)server, client);
-      break;
-    default:
-      assert(0);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb) {
-  int err;
-
-  if (handle->flags & UV_HANDLE_READING) {
-    return UV_EALREADY;
-  }
-
-  if (!(handle->flags & UV_HANDLE_READABLE)) {
-    return UV_ENOTCONN;
-  }
-
-  err = ERROR_INVALID_PARAMETER;
-  switch (handle->type) {
-    case UV_TCP:
-      err = uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
-      break;
-    case UV_NAMED_PIPE:
-      err = uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
-      break;
-    case UV_TTY:
-      err = uv_tty_read_start((uv_tty_t*) handle, alloc_cb, read_cb);
-      break;
-    default:
-      assert(0);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_read_stop(uv_stream_t* handle) {
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_READING))
-    return 0;
-
-  err = 0;
-  if (handle->type == UV_TTY) {
-    err = uv_tty_read_stop((uv_tty_t*) handle);
-  } else if (handle->type == UV_NAMED_PIPE) {
-    uv__pipe_read_stop((uv_pipe_t*) handle);
-  } else {
-    handle->flags &= ~UV_HANDLE_READING;
-    DECREASE_ACTIVE_COUNT(handle->loop, handle);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_write(uv_write_t* req,
-             uv_stream_t* handle,
-             const uv_buf_t bufs[],
-             unsigned int nbufs,
-             uv_write_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_WRITABLE)) {
-    return UV_EPIPE;
-  }
-
-  err = ERROR_INVALID_PARAMETER;
-  switch (handle->type) {
-    case UV_TCP:
-      err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, nbufs, cb);
-      break;
-    case UV_NAMED_PIPE:
-      err = uv__pipe_write(
-          loop, req, (uv_pipe_t*) handle, bufs, nbufs, NULL, cb);
-      break;
-    case UV_TTY:
-      err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, nbufs, cb);
-      break;
-    default:
-      assert(0);
-  }
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_write2(uv_write_t* req,
-              uv_stream_t* handle,
-              const uv_buf_t bufs[],
-              unsigned int nbufs,
-              uv_stream_t* send_handle,
-              uv_write_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  int err;
-
-  if (send_handle == NULL) {
-    return uv_write(req, handle, bufs, nbufs, cb);
-  }
-
-  if (handle->type != UV_NAMED_PIPE || !((uv_pipe_t*) handle)->ipc) {
-    return UV_EINVAL;
-  } else if (!(handle->flags & UV_HANDLE_WRITABLE)) {
-    return UV_EPIPE;
-  }
-
-  err = uv__pipe_write(
-      loop, req, (uv_pipe_t*) handle, bufs, nbufs, send_handle, cb);
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_try_write(uv_stream_t* stream,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs) {
-  if (stream->flags & UV_HANDLE_CLOSING)
-    return UV_EBADF;
-  if (!(stream->flags & UV_HANDLE_WRITABLE))
-    return UV_EPIPE;
-
-  switch (stream->type) {
-    case UV_TCP:
-      return uv__tcp_try_write((uv_tcp_t*) stream, bufs, nbufs);
-    case UV_TTY:
-      return uv__tty_try_write((uv_tty_t*) stream, bufs, nbufs);
-    case UV_NAMED_PIPE:
-      return UV_EAGAIN;
-    default:
-      assert(0);
-      return UV_ENOSYS;
-  }
-}
-
-
-int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
-  uv_loop_t* loop = handle->loop;
-
-  if (!(handle->flags & UV_HANDLE_WRITABLE)) {
-    return UV_EPIPE;
-  }
-
-  UV_REQ_INIT(req, UV_SHUTDOWN);
-  req->handle = handle;
-  req->cb = cb;
-
-  handle->flags &= ~UV_HANDLE_WRITABLE;
-  handle->stream.conn.shutdown_req = req;
-  handle->reqs_pending++;
-  REGISTER_HANDLE_REQ(loop, handle, req);
-
-  uv_want_endgame(loop, (uv_handle_t*)handle);
-
-  return 0;
-}
-
-
-int uv_is_readable(const uv_stream_t* handle) {
-  return !!(handle->flags & UV_HANDLE_READABLE);
-}
-
-
-int uv_is_writable(const uv_stream_t* handle) {
-  return !!(handle->flags & UV_HANDLE_WRITABLE);
-}
-
-
-int uv_stream_set_blocking(uv_stream_t* handle, int blocking) {
-  if (handle->type != UV_NAMED_PIPE)
-    return UV_EINVAL;
-
-  if (blocking != 0)
-    handle->flags |= UV_HANDLE_BLOCKING_WRITES;
-  else
-    handle->flags &= ~UV_HANDLE_BLOCKING_WRITES;
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/tcp.cpp b/wpiutil/src/main/native/libuv/src/win/tcp.cpp
deleted file mode 100644
index f2cb527..0000000
--- a/wpiutil/src/main/native/libuv/src/win/tcp.cpp
+++ /dev/null
@@ -1,1505 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "stream-inl.h"
-#include "req-inl.h"
-
-
-/*
- * Threshold of active tcp streams for which to preallocate tcp read buffers.
- * (Due to node slab allocator performing poorly under this pattern,
- *  the optimization is temporarily disabled (threshold=0).  This will be
- *  revisited once node allocator is improved.)
- */
-const unsigned int uv_active_tcp_streams_threshold = 0;
-
-/*
- * Number of simultaneous pending AcceptEx calls.
- */
-const unsigned int uv_simultaneous_server_accepts = 32;
-
-/* A zero-size buffer for use by uv_tcp_read */
-static char uv_zero_[] = "";
-
-static int uv__tcp_nodelay(uv_tcp_t* handle, SOCKET socket, int enable) {
-  if (setsockopt(socket,
-                 IPPROTO_TCP,
-                 TCP_NODELAY,
-                 (const char*)&enable,
-                 sizeof enable) == -1) {
-    return WSAGetLastError();
-  }
-  return 0;
-}
-
-
-static int uv__tcp_keepalive(uv_tcp_t* handle, SOCKET socket, int enable, unsigned int delay) {
-  if (setsockopt(socket,
-                 SOL_SOCKET,
-                 SO_KEEPALIVE,
-                 (const char*)&enable,
-                 sizeof enable) == -1) {
-    return WSAGetLastError();
-  }
-
-  if (enable && setsockopt(socket,
-                           IPPROTO_TCP,
-                           TCP_KEEPALIVE,
-                           (const char*)&delay,
-                           sizeof delay) == -1) {
-    return WSAGetLastError();
-  }
-
-  return 0;
-}
-
-
-static int uv_tcp_set_socket(uv_loop_t* loop,
-                             uv_tcp_t* handle,
-                             SOCKET socket,
-                             int family,
-                             int imported) {
-  DWORD yes = 1;
-  int non_ifs_lsp;
-  int err;
-
-  if (handle->socket != INVALID_SOCKET)
-    return UV_EBUSY;
-
-  /* Set the socket to nonblocking mode */
-  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
-    return WSAGetLastError();
-  }
-
-  /* Make the socket non-inheritable */
-  if (!SetHandleInformation((HANDLE) socket, HANDLE_FLAG_INHERIT, 0))
-    return GetLastError();
-
-  /* Associate it with the I/O completion port. Use uv_handle_t pointer as
-   * completion key. */
-  if (CreateIoCompletionPort((HANDLE)socket,
-                             loop->iocp,
-                             (ULONG_PTR)socket,
-                             0) == NULL) {
-    if (imported) {
-      handle->flags |= UV_HANDLE_EMULATE_IOCP;
-    } else {
-      return GetLastError();
-    }
-  }
-
-  if (family == AF_INET6) {
-    non_ifs_lsp = uv_tcp_non_ifs_lsp_ipv6;
-  } else {
-    non_ifs_lsp = uv_tcp_non_ifs_lsp_ipv4;
-  }
-
-  if (!(handle->flags & UV_HANDLE_EMULATE_IOCP) && !non_ifs_lsp) {
-    UCHAR sfcnm_flags =
-        FILE_SKIP_SET_EVENT_ON_HANDLE | FILE_SKIP_COMPLETION_PORT_ON_SUCCESS;
-    if (!SetFileCompletionNotificationModes((HANDLE) socket, sfcnm_flags))
-      return GetLastError();
-    handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
-  }
-
-  if (handle->flags & UV_HANDLE_TCP_NODELAY) {
-    err = uv__tcp_nodelay(handle, socket, 1);
-    if (err)
-      return err;
-  }
-
-  /* TODO: Use stored delay. */
-  if (handle->flags & UV_HANDLE_TCP_KEEPALIVE) {
-    err = uv__tcp_keepalive(handle, socket, 1, 60);
-    if (err)
-      return err;
-  }
-
-  handle->socket = socket;
-
-  if (family == AF_INET6) {
-    handle->flags |= UV_HANDLE_IPV6;
-  } else {
-    assert(!(handle->flags & UV_HANDLE_IPV6));
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* handle, unsigned int flags) {
-  int domain;
-
-  /* Use the lower 8 bits for the domain */
-  domain = flags & 0xFF;
-  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
-    return UV_EINVAL;
-
-  if (flags & ~0xFF)
-    return UV_EINVAL;
-
-  uv_stream_init(loop, (uv_stream_t*) handle, UV_TCP);
-  handle->tcp.serv.accept_reqs = NULL;
-  handle->tcp.serv.pending_accepts = NULL;
-  handle->socket = INVALID_SOCKET;
-  handle->reqs_pending = 0;
-  handle->tcp.serv.func_acceptex = NULL;
-  handle->tcp.conn.func_connectex = NULL;
-  handle->tcp.serv.processed_accepts = 0;
-  handle->delayed_error = 0;
-
-  /* If anything fails beyond this point we need to remove the handle from
-   * the handle queue, since it was added by uv__handle_init in uv_stream_init.
-   */
-
-  if (domain != AF_UNSPEC) {
-    SOCKET sock;
-    DWORD err;
-
-    sock = socket(domain, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-      err = WSAGetLastError();
-      QUEUE_REMOVE(&handle->handle_queue);
-      return uv_translate_sys_error(err);
-    }
-
-    err = uv_tcp_set_socket(handle->loop, handle, sock, domain, 0);
-    if (err) {
-      closesocket(sock);
-      QUEUE_REMOVE(&handle->handle_queue);
-      return uv_translate_sys_error(err);
-    }
-
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* handle) {
-  return uv_tcp_init_ex(loop, handle, AF_UNSPEC);
-}
-
-
-void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
-  int err;
-  unsigned int i;
-  uv_tcp_accept_t* req;
-
-  if (handle->flags & UV_HANDLE_CONNECTION &&
-      handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-
-    UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
-
-    err = 0;
-    if (handle->flags & UV_HANDLE_CLOSING) {
-      err = ERROR_OPERATION_ABORTED;
-    } else if (shutdown(handle->socket, SD_SEND) == SOCKET_ERROR) {
-      err = WSAGetLastError();
-    }
-
-    if (handle->stream.conn.shutdown_req->cb) {
-      handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req,
-                               uv_translate_sys_error(err));
-    }
-
-    handle->stream.conn.shutdown_req = NULL;
-    DECREASE_PENDING_REQ_COUNT(handle);
-    return;
-  }
-
-  if (handle->flags & UV_HANDLE_CLOSING &&
-      handle->reqs_pending == 0) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-
-    if (!(handle->flags & UV_HANDLE_TCP_SOCKET_CLOSED)) {
-      closesocket(handle->socket);
-      handle->socket = INVALID_SOCKET;
-      handle->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
-    }
-
-    if (!(handle->flags & UV_HANDLE_CONNECTION) && handle->tcp.serv.accept_reqs) {
-      if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-        for (i = 0; i < uv_simultaneous_server_accepts; i++) {
-          req = &handle->tcp.serv.accept_reqs[i];
-          if (req->wait_handle != INVALID_HANDLE_VALUE) {
-            UnregisterWait(req->wait_handle);
-            req->wait_handle = INVALID_HANDLE_VALUE;
-          }
-          if (req->event_handle) {
-            CloseHandle(req->event_handle);
-            req->event_handle = NULL;
-          }
-        }
-      }
-
-      uv__free(handle->tcp.serv.accept_reqs);
-      handle->tcp.serv.accept_reqs = NULL;
-    }
-
-    if (handle->flags & UV_HANDLE_CONNECTION &&
-        handle->flags & UV_HANDLE_EMULATE_IOCP) {
-      if (handle->read_req.wait_handle != INVALID_HANDLE_VALUE) {
-        UnregisterWait(handle->read_req.wait_handle);
-        handle->read_req.wait_handle = INVALID_HANDLE_VALUE;
-      }
-      if (handle->read_req.event_handle) {
-        CloseHandle(handle->read_req.event_handle);
-        handle->read_req.event_handle = NULL;
-      }
-    }
-
-    uv__handle_close(handle);
-    loop->active_tcp_streams--;
-  }
-}
-
-
-/* Unlike on Unix, here we don't set SO_REUSEADDR, because it doesn't just
- * allow binding to addresses that are in use by sockets in TIME_WAIT, it
- * effectively allows 'stealing' a port which is in use by another application.
- *
- * SO_EXCLUSIVEADDRUSE is also not good here because it does check all sockets,
- * regardless of state, so we'd get an error even if the port is in use by a
- * socket in TIME_WAIT state.
- *
- * See issue #1360.
- *
- */
-static int uv_tcp_try_bind(uv_tcp_t* handle,
-                           const struct sockaddr* addr,
-                           unsigned int addrlen,
-                           unsigned int flags) {
-  DWORD err;
-  int r;
-
-  if (handle->socket == INVALID_SOCKET) {
-    SOCKET sock;
-
-    /* Cannot set IPv6-only mode on non-IPv6 socket. */
-    if ((flags & UV_TCP_IPV6ONLY) && addr->sa_family != AF_INET6)
-      return ERROR_INVALID_PARAMETER;
-
-    sock = socket(addr->sa_family, SOCK_STREAM, 0);
-    if (sock == INVALID_SOCKET) {
-      return WSAGetLastError();
-    }
-
-    err = uv_tcp_set_socket(handle->loop, handle, sock, addr->sa_family, 0);
-    if (err) {
-      closesocket(sock);
-      return err;
-    }
-  }
-
-#ifdef IPV6_V6ONLY
-  if (addr->sa_family == AF_INET6) {
-    int on;
-
-    on = (flags & UV_TCP_IPV6ONLY) != 0;
-
-    /* TODO: how to handle errors? This may fail if there is no ipv4 stack
-     * available, or when run on XP/2003 which have no support for dualstack
-     * sockets. For now we're silently ignoring the error. */
-    setsockopt(handle->socket,
-               IPPROTO_IPV6,
-               IPV6_V6ONLY,
-               (const char*)&on,
-               sizeof on);
-  }
-#endif
-
-  r = bind(handle->socket, addr, addrlen);
-
-  if (r == SOCKET_ERROR) {
-    err = WSAGetLastError();
-    if (err == WSAEADDRINUSE) {
-      /* Some errors are not to be reported until connect() or listen() */
-      handle->delayed_error = err;
-    } else {
-      return err;
-    }
-  }
-
-  handle->flags |= UV_HANDLE_BOUND;
-
-  return 0;
-}
-
-
-static void CALLBACK post_completion(void* context, BOOLEAN timed_out) {
-  uv_req_t* req;
-  uv_tcp_t* handle;
-
-  req = (uv_req_t*) context;
-  assert(req != NULL);
-  handle = (uv_tcp_t*)req->data;
-  assert(handle != NULL);
-  assert(!timed_out);
-
-  if (!PostQueuedCompletionStatus(handle->loop->iocp,
-                                  req->u.io.overlapped.InternalHigh,
-                                  0,
-                                  &req->u.io.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
-}
-
-
-static void CALLBACK post_write_completion(void* context, BOOLEAN timed_out) {
-  uv_write_t* req;
-  uv_tcp_t* handle;
-
-  req = (uv_write_t*) context;
-  assert(req != NULL);
-  handle = (uv_tcp_t*)req->handle;
-  assert(handle != NULL);
-  assert(!timed_out);
-
-  if (!PostQueuedCompletionStatus(handle->loop->iocp,
-                                  req->u.io.overlapped.InternalHigh,
-                                  0,
-                                  &req->u.io.overlapped)) {
-    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
-  }
-}
-
-
-static void uv_tcp_queue_accept(uv_tcp_t* handle, uv_tcp_accept_t* req) {
-  uv_loop_t* loop = handle->loop;
-  BOOL success;
-  DWORD bytes;
-  SOCKET accept_socket;
-  short family;
-
-  assert(handle->flags & UV_HANDLE_LISTENING);
-  assert(req->accept_socket == INVALID_SOCKET);
-
-  /* choose family and extension function */
-  if (handle->flags & UV_HANDLE_IPV6) {
-    family = AF_INET6;
-  } else {
-    family = AF_INET;
-  }
-
-  /* Open a socket for the accepted connection. */
-  accept_socket = socket(family, SOCK_STREAM, 0);
-  if (accept_socket == INVALID_SOCKET) {
-    SET_REQ_ERROR(req, WSAGetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-    handle->reqs_pending++;
-    return;
-  }
-
-  /* Make the socket non-inheritable */
-  if (!SetHandleInformation((HANDLE) accept_socket, HANDLE_FLAG_INHERIT, 0)) {
-    SET_REQ_ERROR(req, GetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-    handle->reqs_pending++;
-    closesocket(accept_socket);
-    return;
-  }
-
-  /* Prepare the overlapped structure. */
-  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
-  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-    req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
-  }
-
-  success = handle->tcp.serv.func_acceptex(handle->socket,
-                                          accept_socket,
-                                          (void*)req->accept_buffer,
-                                          0,
-                                          sizeof(struct sockaddr_storage),
-                                          sizeof(struct sockaddr_storage),
-                                          &bytes,
-                                          &req->u.io.overlapped);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
-    /* Process the req without IOCP. */
-    req->accept_socket = accept_socket;
-    handle->reqs_pending++;
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
-    /* The req will be processed with IOCP. */
-    req->accept_socket = accept_socket;
-    handle->reqs_pending++;
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
-        req->wait_handle == INVALID_HANDLE_VALUE &&
-        !RegisterWaitForSingleObject(&req->wait_handle,
-          req->event_handle, post_completion, (void*) req,
-          INFINITE, WT_EXECUTEINWAITTHREAD)) {
-      SET_REQ_ERROR(req, GetLastError());
-      uv_insert_pending_req(loop, (uv_req_t*)req);
-    }
-  } else {
-    /* Make this req pending reporting an error. */
-    SET_REQ_ERROR(req, WSAGetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-    handle->reqs_pending++;
-    /* Destroy the preallocated client socket. */
-    closesocket(accept_socket);
-    /* Destroy the event handle */
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-      CloseHandle(req->u.io.overlapped.hEvent);
-      req->event_handle = NULL;
-    }
-  }
-}
-
-
-static void uv_tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) {
-  uv_read_t* req;
-  uv_buf_t buf;
-  int result;
-  DWORD bytes, flags;
-
-  assert(handle->flags & UV_HANDLE_READING);
-  assert(!(handle->flags & UV_HANDLE_READ_PENDING));
-
-  req = &handle->read_req;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  /*
-   * Preallocate a read buffer if the number of active streams is below
-   * the threshold.
-  */
-  if (loop->active_tcp_streams < uv_active_tcp_streams_threshold) {
-    handle->flags &= ~UV_HANDLE_ZERO_READ;
-    handle->tcp.conn.read_buffer = uv_buf_init(NULL, 0);
-    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->tcp.conn.read_buffer);
-    if (handle->tcp.conn.read_buffer.base == NULL ||
-        handle->tcp.conn.read_buffer.len == 0) {
-      handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &handle->tcp.conn.read_buffer);
-      return;
-    }
-    assert(handle->tcp.conn.read_buffer.base != NULL);
-    buf = handle->tcp.conn.read_buffer;
-  } else {
-    handle->flags |= UV_HANDLE_ZERO_READ;
-    buf.base = (char*) &uv_zero_;
-    buf.len = 0;
-  }
-
-  /* Prepare the overlapped structure. */
-  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
-  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-    assert(req->event_handle);
-    req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
-  }
-
-  flags = 0;
-  result = WSARecv(handle->socket,
-                   (WSABUF*)&buf,
-                   1,
-                   &bytes,
-                   &flags,
-                   &req->u.io.overlapped,
-                   NULL);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
-    /* Process the req without IOCP. */
-    handle->flags |= UV_HANDLE_READ_PENDING;
-    req->u.io.overlapped.InternalHigh = bytes;
-    handle->reqs_pending++;
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
-    /* The req will be processed with IOCP. */
-    handle->flags |= UV_HANDLE_READ_PENDING;
-    handle->reqs_pending++;
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
-        req->wait_handle == INVALID_HANDLE_VALUE &&
-        !RegisterWaitForSingleObject(&req->wait_handle,
-          req->event_handle, post_completion, (void*) req,
-          INFINITE, WT_EXECUTEINWAITTHREAD)) {
-      SET_REQ_ERROR(req, GetLastError());
-      uv_insert_pending_req(loop, (uv_req_t*)req);
-    }
-  } else {
-    /* Make this req pending reporting an error. */
-    SET_REQ_ERROR(req, WSAGetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-    handle->reqs_pending++;
-  }
-}
-
-
-int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
-  unsigned int i, simultaneous_accepts;
-  uv_tcp_accept_t* req;
-  int err;
-
-  assert(backlog > 0);
-
-  if (handle->flags & UV_HANDLE_LISTENING) {
-    handle->stream.serv.connection_cb = cb;
-  }
-
-  if (handle->flags & UV_HANDLE_READING) {
-    return WSAEISCONN;
-  }
-
-  if (handle->delayed_error) {
-    return handle->delayed_error;
-  }
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_tcp_try_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip4_any_,
-                          sizeof(uv_addr_ip4_any_),
-                          0);
-    if (err)
-      return err;
-    if (handle->delayed_error)
-      return handle->delayed_error;
-  }
-
-  if (!handle->tcp.serv.func_acceptex) {
-    if (!uv_get_acceptex_function(handle->socket, &handle->tcp.serv.func_acceptex)) {
-      return WSAEAFNOSUPPORT;
-    }
-  }
-
-  if (!(handle->flags & UV_HANDLE_SHARED_TCP_SOCKET) &&
-      listen(handle->socket, backlog) == SOCKET_ERROR) {
-    return WSAGetLastError();
-  }
-
-  handle->flags |= UV_HANDLE_LISTENING;
-  handle->stream.serv.connection_cb = cb;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-
-  simultaneous_accepts = handle->flags & UV_HANDLE_TCP_SINGLE_ACCEPT ? 1
-    : uv_simultaneous_server_accepts;
-
-  if(!handle->tcp.serv.accept_reqs) {
-    handle->tcp.serv.accept_reqs = (uv_tcp_accept_t*)
-      uv__malloc(uv_simultaneous_server_accepts * sizeof(uv_tcp_accept_t));
-    if (!handle->tcp.serv.accept_reqs) {
-      uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-    }
-
-    for (i = 0; i < simultaneous_accepts; i++) {
-      req = &handle->tcp.serv.accept_reqs[i];
-      UV_REQ_INIT(req, UV_ACCEPT);
-      req->accept_socket = INVALID_SOCKET;
-      req->data = handle;
-
-      req->wait_handle = INVALID_HANDLE_VALUE;
-      if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-        req->event_handle = CreateEvent(NULL, 0, 0, NULL);
-        if (!req->event_handle) {
-          uv_fatal_error(GetLastError(), "CreateEvent");
-        }
-      } else {
-        req->event_handle = NULL;
-      }
-
-      uv_tcp_queue_accept(handle, req);
-    }
-
-    /* Initialize other unused requests too, because uv_tcp_endgame doesn't
-     * know how many requests were initialized, so it will try to clean up
-     * {uv_simultaneous_server_accepts} requests. */
-    for (i = simultaneous_accepts; i < uv_simultaneous_server_accepts; i++) {
-      req = &handle->tcp.serv.accept_reqs[i];
-      UV_REQ_INIT(req, UV_ACCEPT);
-      req->accept_socket = INVALID_SOCKET;
-      req->data = handle;
-      req->wait_handle = INVALID_HANDLE_VALUE;
-      req->event_handle = NULL;
-    }
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
-  uv_loop_t* loop = server->loop;
-  int err = 0;
-  int family;
-
-  uv_tcp_accept_t* req = server->tcp.serv.pending_accepts;
-
-  if (!req) {
-    /* No valid connections found, so we error out. */
-    return WSAEWOULDBLOCK;
-  }
-
-  if (req->accept_socket == INVALID_SOCKET) {
-    return WSAENOTCONN;
-  }
-
-  if (server->flags & UV_HANDLE_IPV6) {
-    family = AF_INET6;
-  } else {
-    family = AF_INET;
-  }
-
-  err = uv_tcp_set_socket(client->loop,
-                          client,
-                          req->accept_socket,
-                          family,
-                          0);
-  if (err) {
-    closesocket(req->accept_socket);
-  } else {
-    uv_connection_init((uv_stream_t*) client);
-    /* AcceptEx() implicitly binds the accepted socket. */
-    client->flags |= UV_HANDLE_BOUND | UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-  }
-
-  /* Prepare the req to pick up a new connection */
-  server->tcp.serv.pending_accepts = req->next_pending;
-  req->next_pending = NULL;
-  req->accept_socket = INVALID_SOCKET;
-
-  if (!(server->flags & UV_HANDLE_CLOSING)) {
-    /* Check if we're in a middle of changing the number of pending accepts. */
-    if (!(server->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING)) {
-      uv_tcp_queue_accept(server, req);
-    } else {
-      /* We better be switching to a single pending accept. */
-      assert(server->flags & UV_HANDLE_TCP_SINGLE_ACCEPT);
-
-      server->tcp.serv.processed_accepts++;
-
-      if (server->tcp.serv.processed_accepts >= uv_simultaneous_server_accepts) {
-        server->tcp.serv.processed_accepts = 0;
-        /*
-         * All previously queued accept requests are now processed.
-         * We now switch to queueing just a single accept.
-         */
-        uv_tcp_queue_accept(server, &server->tcp.serv.accept_reqs[0]);
-        server->flags &= ~UV_HANDLE_TCP_ACCEPT_STATE_CHANGING;
-        server->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
-      }
-    }
-  }
-
-  loop->active_tcp_streams++;
-
-  return err;
-}
-
-
-int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb) {
-  uv_loop_t* loop = handle->loop;
-
-  handle->flags |= UV_HANDLE_READING;
-  handle->read_cb = read_cb;
-  handle->alloc_cb = alloc_cb;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-
-  /* If reading was stopped and then started again, there could still be a read
-   * request pending. */
-  if (!(handle->flags & UV_HANDLE_READ_PENDING)) {
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
-        !handle->read_req.event_handle) {
-      handle->read_req.event_handle = CreateEvent(NULL, 0, 0, NULL);
-      if (!handle->read_req.event_handle) {
-        uv_fatal_error(GetLastError(), "CreateEvent");
-      }
-    }
-    uv_tcp_queue_read(loop, handle);
-  }
-
-  return 0;
-}
-
-
-static int uv_tcp_try_connect(uv_connect_t* req,
-                              uv_tcp_t* handle,
-                              const struct sockaddr* addr,
-                              unsigned int addrlen,
-                              uv_connect_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  const struct sockaddr* bind_addr;
-  struct sockaddr_storage converted;
-  BOOL success;
-  DWORD bytes;
-  int err;
-
-  err = uv__convert_to_localhost_if_unspecified(addr, &converted);
-  if (err)
-    return err;
-
-  if (handle->delayed_error) {
-    return handle->delayed_error;
-  }
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    if (addrlen == sizeof(uv_addr_ip4_any_)) {
-      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
-    } else if (addrlen == sizeof(uv_addr_ip6_any_)) {
-      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
-    } else {
-      abort();
-    }
-    err = uv_tcp_try_bind(handle, bind_addr, addrlen, 0);
-    if (err)
-      return err;
-    if (handle->delayed_error)
-      return handle->delayed_error;
-  }
-
-  if (!handle->tcp.conn.func_connectex) {
-    if (!uv_get_connectex_function(handle->socket, &handle->tcp.conn.func_connectex)) {
-      return WSAEAFNOSUPPORT;
-    }
-  }
-
-  UV_REQ_INIT(req, UV_CONNECT);
-  req->handle = (uv_stream_t*) handle;
-  req->cb = cb;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  success = handle->tcp.conn.func_connectex(handle->socket,
-                                            (const struct sockaddr*) &converted,
-                                            addrlen,
-                                            NULL,
-                                            0,
-                                            &bytes,
-                                            &req->u.io.overlapped);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
-    /* Process the req without IOCP. */
-    handle->reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
-    /* The req will be processed with IOCP. */
-    handle->reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-  } else {
-    return WSAGetLastError();
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_getsockname(const uv_tcp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getsockname,
-                             name,
-                             namelen,
-                             handle->delayed_error);
-}
-
-
-int uv_tcp_getpeername(const uv_tcp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getpeername,
-                             name,
-                             namelen,
-                             handle->delayed_error);
-}
-
-
-int uv_tcp_write(uv_loop_t* loop,
-                 uv_write_t* req,
-                 uv_tcp_t* handle,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs,
-                 uv_write_cb cb) {
-  int result;
-  DWORD bytes;
-
-  UV_REQ_INIT(req, UV_WRITE);
-  req->handle = (uv_stream_t*) handle;
-  req->cb = cb;
-
-  /* Prepare the overlapped structure. */
-  memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
-  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-    req->event_handle = CreateEvent(NULL, 0, 0, NULL);
-    if (!req->event_handle) {
-      uv_fatal_error(GetLastError(), "CreateEvent");
-    }
-    req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
-    req->wait_handle = INVALID_HANDLE_VALUE;
-  }
-
-  result = WSASend(handle->socket,
-                   (WSABUF*) bufs,
-                   nbufs,
-                   &bytes,
-                   0,
-                   &req->u.io.overlapped,
-                   NULL);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
-    /* Request completed immediately. */
-    req->u.io.queued_bytes = 0;
-    handle->reqs_pending++;
-    handle->stream.conn.write_reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    uv_insert_pending_req(loop, (uv_req_t*) req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
-    /* Request queued by the kernel. */
-    req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
-    handle->reqs_pending++;
-    handle->stream.conn.write_reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    handle->write_queue_size += req->u.io.queued_bytes;
-    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
-        !RegisterWaitForSingleObject(&req->wait_handle,
-          req->event_handle, post_write_completion, (void*) req,
-          INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) {
-      SET_REQ_ERROR(req, GetLastError());
-      uv_insert_pending_req(loop, (uv_req_t*)req);
-    }
-  } else {
-    /* Send failed due to an error, report it later */
-    req->u.io.queued_bytes = 0;
-    handle->reqs_pending++;
-    handle->stream.conn.write_reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    SET_REQ_ERROR(req, WSAGetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*) req);
-  }
-
-  return 0;
-}
-
-
-int uv__tcp_try_write(uv_tcp_t* handle,
-                     const uv_buf_t bufs[],
-                     unsigned int nbufs) {
-  int result;
-  DWORD bytes;
-
-  if (handle->stream.conn.write_reqs_pending > 0)
-    return UV_EAGAIN;
-
-  result = WSASend(handle->socket,
-                   (WSABUF*) bufs,
-                   nbufs,
-                   &bytes,
-                   0,
-                   NULL,
-                   NULL);
-
-  if (result == SOCKET_ERROR)
-    return uv_translate_sys_error(WSAGetLastError());
-  else
-    return bytes;
-}
-
-
-void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_req_t* req) {
-  DWORD bytes, flags, err;
-  uv_buf_t buf;
-  int count;
-
-  assert(handle->type == UV_TCP);
-
-  handle->flags &= ~UV_HANDLE_READ_PENDING;
-
-  if (!REQ_SUCCESS(req)) {
-    /* An error occurred doing the read. */
-    if ((handle->flags & UV_HANDLE_READING) ||
-        !(handle->flags & UV_HANDLE_ZERO_READ)) {
-      handle->flags &= ~UV_HANDLE_READING;
-      DECREASE_ACTIVE_COUNT(loop, handle);
-      buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
-            uv_buf_init(NULL, 0) : handle->tcp.conn.read_buffer;
-
-      err = GET_REQ_SOCK_ERROR(req);
-
-      if (err == WSAECONNABORTED) {
-        /* Turn WSAECONNABORTED into UV_ECONNRESET to be consistent with Unix.
-         */
-        err = WSAECONNRESET;
-      }
-
-      handle->read_cb((uv_stream_t*)handle,
-                      uv_translate_sys_error(err),
-                      &buf);
-    }
-  } else {
-    if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
-      /* The read was done with a non-zero buffer length. */
-      if (req->u.io.overlapped.InternalHigh > 0) {
-        /* Successful read */
-        handle->read_cb((uv_stream_t*)handle,
-                        req->u.io.overlapped.InternalHigh,
-                        &handle->tcp.conn.read_buffer);
-        /* Read again only if bytes == buf.len */
-        if (req->u.io.overlapped.InternalHigh < handle->tcp.conn.read_buffer.len) {
-          goto done;
-        }
-      } else {
-        /* Connection closed */
-        if (handle->flags & UV_HANDLE_READING) {
-          handle->flags &= ~UV_HANDLE_READING;
-          DECREASE_ACTIVE_COUNT(loop, handle);
-        }
-        handle->flags &= ~UV_HANDLE_READABLE;
-
-        buf.base = 0;
-        buf.len = 0;
-        handle->read_cb((uv_stream_t*)handle, UV_EOF, &handle->tcp.conn.read_buffer);
-        goto done;
-      }
-    }
-
-    /* Do nonblocking reads until the buffer is empty */
-    count = 32;
-    while ((handle->flags & UV_HANDLE_READING) && (count-- > 0)) {
-      buf = uv_buf_init(NULL, 0);
-      handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
-      if (buf.base == NULL || buf.len == 0) {
-        handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
-        break;
-      }
-      assert(buf.base != NULL);
-
-      flags = 0;
-      if (WSARecv(handle->socket,
-                  (WSABUF*)&buf,
-                  1,
-                  &bytes,
-                  &flags,
-                  NULL,
-                  NULL) != SOCKET_ERROR) {
-        if (bytes > 0) {
-          /* Successful read */
-          handle->read_cb((uv_stream_t*)handle, bytes, &buf);
-          /* Read again only if bytes == buf.len */
-          if (bytes < buf.len) {
-            break;
-          }
-        } else {
-          /* Connection closed */
-          handle->flags &= ~(UV_HANDLE_READING | UV_HANDLE_READABLE);
-          DECREASE_ACTIVE_COUNT(loop, handle);
-
-          handle->read_cb((uv_stream_t*)handle, UV_EOF, &buf);
-          break;
-        }
-      } else {
-        err = WSAGetLastError();
-        if (err == WSAEWOULDBLOCK) {
-          /* Read buffer was completely empty, report a 0-byte read. */
-          handle->read_cb((uv_stream_t*)handle, 0, &buf);
-        } else {
-          /* Ouch! serious error. */
-          handle->flags &= ~UV_HANDLE_READING;
-          DECREASE_ACTIVE_COUNT(loop, handle);
-
-          if (err == WSAECONNABORTED) {
-            /* Turn WSAECONNABORTED into UV_ECONNRESET to be consistent with
-             * Unix. */
-            err = WSAECONNRESET;
-          }
-
-          handle->read_cb((uv_stream_t*)handle,
-                          uv_translate_sys_error(err),
-                          &buf);
-        }
-        break;
-      }
-    }
-
-done:
-    /* Post another read if still reading and not closing. */
-    if ((handle->flags & UV_HANDLE_READING) &&
-        !(handle->flags & UV_HANDLE_READ_PENDING)) {
-      uv_tcp_queue_read(loop, handle);
-    }
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_write_t* req) {
-  int err;
-
-  assert(handle->type == UV_TCP);
-
-  assert(handle->write_queue_size >= req->u.io.queued_bytes);
-  handle->write_queue_size -= req->u.io.queued_bytes;
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
-    if (req->wait_handle != INVALID_HANDLE_VALUE) {
-      UnregisterWait(req->wait_handle);
-      req->wait_handle = INVALID_HANDLE_VALUE;
-    }
-    if (req->event_handle) {
-      CloseHandle(req->event_handle);
-      req->event_handle = NULL;
-    }
-  }
-
-  if (req->cb) {
-    err = uv_translate_sys_error(GET_REQ_SOCK_ERROR(req));
-    if (err == UV_ECONNABORTED) {
-      /* use UV_ECANCELED for consistency with Unix */
-      err = UV_ECANCELED;
-    }
-    req->cb(req, err);
-  }
-
-  handle->stream.conn.write_reqs_pending--;
-  if (handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_req_t* raw_req) {
-  uv_tcp_accept_t* req = (uv_tcp_accept_t*) raw_req;
-  int err;
-
-  assert(handle->type == UV_TCP);
-
-  /* If handle->accepted_socket is not a valid socket, then uv_queue_accept
-   * must have failed. This is a serious error. We stop accepting connections
-   * and report this error to the connection callback. */
-  if (req->accept_socket == INVALID_SOCKET) {
-    if (handle->flags & UV_HANDLE_LISTENING) {
-      handle->flags &= ~UV_HANDLE_LISTENING;
-      DECREASE_ACTIVE_COUNT(loop, handle);
-      if (handle->stream.serv.connection_cb) {
-        err = GET_REQ_SOCK_ERROR(req);
-        handle->stream.serv.connection_cb((uv_stream_t*)handle,
-                                      uv_translate_sys_error(err));
-      }
-    }
-  } else if (REQ_SUCCESS(req) &&
-      setsockopt(req->accept_socket,
-                  SOL_SOCKET,
-                  SO_UPDATE_ACCEPT_CONTEXT,
-                  (char*)&handle->socket,
-                  sizeof(handle->socket)) == 0) {
-    req->next_pending = handle->tcp.serv.pending_accepts;
-    handle->tcp.serv.pending_accepts = req;
-
-    /* Accept and SO_UPDATE_ACCEPT_CONTEXT were successful. */
-    if (handle->stream.serv.connection_cb) {
-      handle->stream.serv.connection_cb((uv_stream_t*)handle, 0);
-    }
-  } else {
-    /* Error related to accepted socket is ignored because the server socket
-     * may still be healthy. If the server socket is broken uv_queue_accept
-     * will detect it. */
-    closesocket(req->accept_socket);
-    req->accept_socket = INVALID_SOCKET;
-    if (handle->flags & UV_HANDLE_LISTENING) {
-      uv_tcp_queue_accept(handle, req);
-    }
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
-    uv_connect_t* req) {
-  int err;
-
-  assert(handle->type == UV_TCP);
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  err = 0;
-  if (REQ_SUCCESS(req)) {
-    if (handle->flags & UV_HANDLE_CLOSING) {
-      /* use UV_ECANCELED for consistency with Unix */
-      err = ERROR_OPERATION_ABORTED;
-    } else if (setsockopt(handle->socket,
-                          SOL_SOCKET,
-                          SO_UPDATE_CONNECT_CONTEXT,
-                          NULL,
-                          0) == 0) {
-      uv_connection_init((uv_stream_t*)handle);
-      handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-      loop->active_tcp_streams++;
-    } else {
-      err = WSAGetLastError();
-    }
-  } else {
-    err = GET_REQ_SOCK_ERROR(req);
-  }
-  req->cb(req, uv_translate_sys_error(err));
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-int uv__tcp_xfer_export(uv_tcp_t* handle,
-                        int target_pid,
-                        uv__ipc_socket_xfer_type_t* xfer_type,
-                        uv__ipc_socket_xfer_info_t* xfer_info) {
-  if (handle->flags & UV_HANDLE_CONNECTION) {
-    *xfer_type = UV__IPC_SOCKET_XFER_TCP_CONNECTION;
-  } else {
-    *xfer_type = UV__IPC_SOCKET_XFER_TCP_SERVER;
-    /* We're about to share the socket with another process. Because this is a
-     * listening socket, we assume that the other process will be accepting
-     * connections on it. Thus, before sharing the socket with another process,
-     * we call listen here in the parent process. */
-    if (!(handle->flags & UV_HANDLE_LISTENING)) {
-      if (!(handle->flags & UV_HANDLE_BOUND)) {
-        return ERROR_NOT_SUPPORTED;
-      }
-      if (handle->delayed_error == 0 &&
-          listen(handle->socket, SOMAXCONN) == SOCKET_ERROR) {
-        handle->delayed_error = WSAGetLastError();
-      }
-    }
-  }
-
-  if (WSADuplicateSocketW(handle->socket, target_pid, &xfer_info->socket_info))
-    return WSAGetLastError();
-  xfer_info->delayed_error = handle->delayed_error;
-
-  /* Mark the local copy of the handle as 'shared' so we behave in a way that's
-   * friendly to the process(es) that we share the socket with. */
-  handle->flags |= UV_HANDLE_SHARED_TCP_SOCKET;
-
-  return 0;
-}
-
-
-int uv__tcp_xfer_import(uv_tcp_t* tcp,
-                        uv__ipc_socket_xfer_type_t xfer_type,
-                        uv__ipc_socket_xfer_info_t* xfer_info) {
-  int err;
-  SOCKET socket;
-
-  assert(xfer_type == UV__IPC_SOCKET_XFER_TCP_SERVER ||
-         xfer_type == UV__IPC_SOCKET_XFER_TCP_CONNECTION);
-
-  socket = WSASocketW(FROM_PROTOCOL_INFO,
-                      FROM_PROTOCOL_INFO,
-                      FROM_PROTOCOL_INFO,
-                      &xfer_info->socket_info,
-                      0,
-                      WSA_FLAG_OVERLAPPED);
-
-  if (socket == INVALID_SOCKET) {
-    return WSAGetLastError();
-  }
-
-  err = uv_tcp_set_socket(
-      tcp->loop, tcp, socket, xfer_info->socket_info.iAddressFamily, 1);
-  if (err) {
-    closesocket(socket);
-    return err;
-  }
-
-  tcp->delayed_error = xfer_info->delayed_error;
-  tcp->flags |= UV_HANDLE_BOUND | UV_HANDLE_SHARED_TCP_SOCKET;
-
-  if (xfer_type == UV__IPC_SOCKET_XFER_TCP_CONNECTION) {
-    uv_connection_init((uv_stream_t*)tcp);
-    tcp->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-  }
-
-  tcp->loop->active_tcp_streams++;
-  return 0;
-}
-
-
-int uv_tcp_nodelay(uv_tcp_t* handle, int enable) {
-  int err;
-
-  if (handle->socket != INVALID_SOCKET) {
-    err = uv__tcp_nodelay(handle, handle->socket, enable);
-    if (err)
-      return err;
-  }
-
-  if (enable) {
-    handle->flags |= UV_HANDLE_TCP_NODELAY;
-  } else {
-    handle->flags &= ~UV_HANDLE_TCP_NODELAY;
-  }
-
-  return 0;
-}
-
-
-int uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay) {
-  int err;
-
-  if (handle->socket != INVALID_SOCKET) {
-    err = uv__tcp_keepalive(handle, handle->socket, enable, delay);
-    if (err)
-      return err;
-  }
-
-  if (enable) {
-    handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
-  } else {
-    handle->flags &= ~UV_HANDLE_TCP_KEEPALIVE;
-  }
-
-  /* TODO: Store delay if handle->socket isn't created yet. */
-
-  return 0;
-}
-
-
-int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) {
-  if (handle->flags & UV_HANDLE_CONNECTION) {
-    return UV_EINVAL;
-  }
-
-  /* Check if we're already in the desired mode. */
-  if ((enable && !(handle->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) ||
-      (!enable && handle->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
-    return 0;
-  }
-
-  /* Don't allow switching from single pending accept to many. */
-  if (enable) {
-    return UV_ENOTSUP;
-  }
-
-  /* Check if we're in a middle of changing the number of pending accepts. */
-  if (handle->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING) {
-    return 0;
-  }
-
-  handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
-
-  /* Flip the changing flag if we have already queued multiple accepts. */
-  if (handle->flags & UV_HANDLE_LISTENING) {
-    handle->flags |= UV_HANDLE_TCP_ACCEPT_STATE_CHANGING;
-  }
-
-  return 0;
-}
-
-
-static int uv_tcp_try_cancel_io(uv_tcp_t* tcp) {
-  SOCKET socket = tcp->socket;
-  int non_ifs_lsp;
-
-  /* Check if we have any non-IFS LSPs stacked on top of TCP */
-  non_ifs_lsp = (tcp->flags & UV_HANDLE_IPV6) ? uv_tcp_non_ifs_lsp_ipv6 :
-                                                uv_tcp_non_ifs_lsp_ipv4;
-
-  /* If there are non-ifs LSPs then try to obtain a base handle for the socket.
-   * This will always fail on Windows XP/3k. */
-  if (non_ifs_lsp) {
-    DWORD bytes;
-    if (WSAIoctl(socket,
-                 SIO_BASE_HANDLE,
-                 NULL,
-                 0,
-                 &socket,
-                 sizeof socket,
-                 &bytes,
-                 NULL,
-                 NULL) != 0) {
-      /* Failed. We can't do CancelIo. */
-      return -1;
-    }
-  }
-
-  assert(socket != 0 && socket != INVALID_SOCKET);
-
-  if (!CancelIo((HANDLE) socket)) {
-    return GetLastError();
-  }
-
-  /* It worked. */
-  return 0;
-}
-
-
-void uv_tcp_close(uv_loop_t* loop, uv_tcp_t* tcp) {
-  int close_socket = 1;
-
-  if (tcp->flags & UV_HANDLE_READ_PENDING) {
-    /* In order for winsock to do a graceful close there must not be any any
-     * pending reads, or the socket must be shut down for writing */
-    if (!(tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET)) {
-      /* Just do shutdown on non-shared sockets, which ensures graceful close. */
-      shutdown(tcp->socket, SD_SEND);
-
-    } else if (uv_tcp_try_cancel_io(tcp) == 0) {
-      /* In case of a shared socket, we try to cancel all outstanding I/O,. If
-       * that works, don't close the socket yet - wait for the read req to
-       * return and close the socket in uv_tcp_endgame. */
-      close_socket = 0;
-
-    } else {
-      /* When cancelling isn't possible - which could happen when an LSP is
-       * present on an old Windows version, we will have to close the socket
-       * with a read pending. That is not nice because trailing sent bytes may
-       * not make it to the other side. */
-    }
-
-  } else if ((tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET) &&
-             tcp->tcp.serv.accept_reqs != NULL) {
-    /* Under normal circumstances closesocket() will ensure that all pending
-     * accept reqs are canceled. However, when the socket is shared the
-     * presence of another reference to the socket in another process will keep
-     * the accept reqs going, so we have to ensure that these are canceled. */
-    if (uv_tcp_try_cancel_io(tcp) != 0) {
-      /* When cancellation is not possible, there is another option: we can
-       * close the incoming sockets, which will also cancel the accept
-       * operations. However this is not cool because we might inadvertently
-       * close a socket that just accepted a new connection, which will cause
-       * the connection to be aborted. */
-      unsigned int i;
-      for (i = 0; i < uv_simultaneous_server_accepts; i++) {
-        uv_tcp_accept_t* req = &tcp->tcp.serv.accept_reqs[i];
-        if (req->accept_socket != INVALID_SOCKET &&
-            !HasOverlappedIoCompleted(&req->u.io.overlapped)) {
-          closesocket(req->accept_socket);
-          req->accept_socket = INVALID_SOCKET;
-        }
-      }
-    }
-  }
-
-  if (tcp->flags & UV_HANDLE_READING) {
-    tcp->flags &= ~UV_HANDLE_READING;
-    DECREASE_ACTIVE_COUNT(loop, tcp);
-  }
-
-  if (tcp->flags & UV_HANDLE_LISTENING) {
-    tcp->flags &= ~UV_HANDLE_LISTENING;
-    DECREASE_ACTIVE_COUNT(loop, tcp);
-  }
-
-  if (close_socket) {
-    closesocket(tcp->socket);
-    tcp->socket = INVALID_SOCKET;
-    tcp->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
-  }
-
-  tcp->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-  uv__handle_closing(tcp);
-
-  if (tcp->reqs_pending == 0) {
-    uv_want_endgame(tcp->loop, (uv_handle_t*)tcp);
-  }
-}
-
-
-int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
-  WSAPROTOCOL_INFOW protocol_info;
-  int opt_len;
-  int err;
-  struct sockaddr_storage saddr;
-  int saddr_len;
-
-  /* Detect the address family of the socket. */
-  opt_len = (int) sizeof protocol_info;
-  if (getsockopt(sock,
-                 SOL_SOCKET,
-                 SO_PROTOCOL_INFOW,
-                 (char*) &protocol_info,
-                 &opt_len) == SOCKET_ERROR) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  err = uv_tcp_set_socket(handle->loop,
-                          handle,
-                          sock,
-                          protocol_info.iAddressFamily,
-                          1);
-  if (err) {
-    return uv_translate_sys_error(err);
-  }
-
-  /* Support already active socket. */
-  saddr_len = sizeof(saddr);
-  if (!uv_tcp_getsockname(handle, (struct sockaddr*) &saddr, &saddr_len)) {
-    /* Socket is already bound. */
-    handle->flags |= UV_HANDLE_BOUND;
-    saddr_len = sizeof(saddr);
-    if (!uv_tcp_getpeername(handle, (struct sockaddr*) &saddr, &saddr_len)) {
-      /* Socket is already connected. */
-      uv_connection_init((uv_stream_t*) handle);
-      handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE;
-    }
-  }
-
-  return 0;
-}
-
-
-/* This function is an egress point, i.e. it returns libuv errors rather than
- * system errors.
- */
-int uv__tcp_bind(uv_tcp_t* handle,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 unsigned int flags) {
-  int err;
-
-  err = uv_tcp_try_bind(handle, addr, addrlen, flags);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  return 0;
-}
-
-
-/* This function is an egress point, i.e. it returns libuv errors rather than
- * system errors.
- */
-int uv__tcp_connect(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen,
-                    uv_connect_cb cb) {
-  int err;
-
-  err = uv_tcp_try_connect(req, handle, addr, addrlen, cb);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/thread.cpp b/wpiutil/src/main/native/libuv/src/win/thread.cpp
deleted file mode 100644
index 72af03c..0000000
--- a/wpiutil/src/main/native/libuv/src/win/thread.cpp
+++ /dev/null
@@ -1,520 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <limits.h>
-#include <stdlib.h>
-
-#if defined(__MINGW64_VERSION_MAJOR)
-/* MemoryBarrier expands to __mm_mfence in some cases (x86+sse2), which may
- * require this header in some versions of mingw64. */
-#include <intrin.h>
-#endif
-
-#include "uv.h"
-#include "internal.h"
-
-static void uv__once_inner(uv_once_t* guard, void (*callback)(void)) {
-  DWORD result;
-  HANDLE existing_event, created_event;
-
-  created_event = CreateEvent(NULL, 1, 0, NULL);
-  if (created_event == 0) {
-    /* Could fail in a low-memory situation? */
-    uv_fatal_error(GetLastError(), "CreateEvent");
-  }
-
-  existing_event = InterlockedCompareExchangePointer(&guard->event,
-                                                     created_event,
-                                                     NULL);
-
-  if (existing_event == NULL) {
-    /* We won the race */
-    callback();
-
-    result = SetEvent(created_event);
-    assert(result);
-    guard->ran = 1;
-
-  } else {
-    /* We lost the race. Destroy the event we created and wait for the existing
-     * one to become signaled. */
-    CloseHandle(created_event);
-    result = WaitForSingleObject(existing_event, INFINITE);
-    assert(result == WAIT_OBJECT_0);
-  }
-}
-
-
-void uv_once(uv_once_t* guard, void (*callback)(void)) {
-  /* Fast case - avoid WaitForSingleObject. */
-  if (guard->ran) {
-    return;
-  }
-
-  uv__once_inner(guard, callback);
-}
-
-
-/* Verify that uv_thread_t can be stored in a TLS slot. */
-STATIC_ASSERT(sizeof(uv_thread_t) <= sizeof(void*));
-
-static uv_key_t uv__current_thread_key;
-static uv_once_t uv__current_thread_init_guard = UV_ONCE_INIT;
-
-
-static void uv__init_current_thread_key(void) {
-  if (uv_key_create(&uv__current_thread_key))
-    abort();
-}
-
-
-struct thread_ctx {
-  void (*entry)(void* arg);
-  void* arg;
-  uv_thread_t self;
-};
-
-
-static UINT __stdcall uv__thread_start(void* arg) {
-  struct thread_ctx *ctx_p;
-  struct thread_ctx ctx;
-
-  ctx_p = (struct thread_ctx*)arg;
-  ctx = *ctx_p;
-  uv__free(ctx_p);
-
-  uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
-  uv_key_set(&uv__current_thread_key, (void*) ctx.self);
-
-  ctx.entry(ctx.arg);
-
-  return 0;
-}
-
-
-int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
-  uv_thread_options_t params;
-  params.flags = UV_THREAD_NO_FLAGS;
-  return uv_thread_create_ex(tid, &params, entry, arg);
-}
-
-int uv_thread_create_ex(uv_thread_t* tid,
-                        const uv_thread_options_t* params,
-                        void (*entry)(void *arg),
-                        void *arg) {
-  struct thread_ctx* ctx;
-  int err;
-  HANDLE thread;
-  SYSTEM_INFO sysinfo;
-  size_t stack_size;
-  size_t pagesize;
-
-  stack_size =
-      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
-
-  if (stack_size != 0) {
-    GetNativeSystemInfo(&sysinfo);
-    pagesize = (size_t)sysinfo.dwPageSize;
-    /* Round up to the nearest page boundary. */
-    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
-
-    if ((unsigned)stack_size != stack_size)
-      return UV_EINVAL;
-  }
-
-  ctx = (struct thread_ctx*)uv__malloc(sizeof(*ctx));
-  if (ctx == NULL)
-    return UV_ENOMEM;
-
-  ctx->entry = entry;
-  ctx->arg = arg;
-
-  /* Create the thread in suspended state so we have a chance to pass
-   * its own creation handle to it */
-  thread = (HANDLE) _beginthreadex(NULL,
-                                   (unsigned)stack_size,
-                                   uv__thread_start,
-                                   ctx,
-                                   CREATE_SUSPENDED,
-                                   NULL);
-  if (thread == NULL) {
-    err = errno;
-    uv__free(ctx);
-  } else {
-    err = 0;
-    *tid = thread;
-    ctx->self = thread;
-    ResumeThread(thread);
-  }
-
-  switch (err) {
-    case 0:
-      return 0;
-    case EACCES:
-      return UV_EACCES;
-    case EAGAIN:
-      return UV_EAGAIN;
-    case EINVAL:
-      return UV_EINVAL;
-  }
-
-  return UV_EIO;
-}
-
-
-uv_thread_t uv_thread_self(void) {
-  uv_once(&uv__current_thread_init_guard, uv__init_current_thread_key);
-  return (uv_thread_t) uv_key_get(&uv__current_thread_key);
-}
-
-
-int uv_thread_join(uv_thread_t *tid) {
-  if (WaitForSingleObject(*tid, INFINITE))
-    return uv_translate_sys_error(GetLastError());
-  else {
-    CloseHandle(*tid);
-    *tid = 0;
-    MemoryBarrier();  /* For feature parity with pthread_join(). */
-    return 0;
-  }
-}
-
-
-int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2) {
-  return *t1 == *t2;
-}
-
-
-int uv_mutex_init(uv_mutex_t* mutex) {
-  InitializeCriticalSection(mutex);
-  return 0;
-}
-
-
-int uv_mutex_init_recursive(uv_mutex_t* mutex) {
-  return uv_mutex_init(mutex);
-}
-
-
-void uv_mutex_destroy(uv_mutex_t* mutex) {
-  DeleteCriticalSection(mutex);
-}
-
-
-void uv_mutex_lock(uv_mutex_t* mutex) {
-  EnterCriticalSection(mutex);
-}
-
-
-int uv_mutex_trylock(uv_mutex_t* mutex) {
-  if (TryEnterCriticalSection(mutex))
-    return 0;
-  else
-    return UV_EBUSY;
-}
-
-
-void uv_mutex_unlock(uv_mutex_t* mutex) {
-  LeaveCriticalSection(mutex);
-}
-
-
-int uv_rwlock_init(uv_rwlock_t* rwlock) {
-  /* Initialize the semaphore that acts as the write lock. */
-  HANDLE handle = CreateSemaphoreW(NULL, 1, 1, NULL);
-  if (handle == NULL)
-    return uv_translate_sys_error(GetLastError());
-  rwlock->state_.write_semaphore_ = handle;
-
-  /* Initialize the critical section protecting the reader count. */
-  InitializeCriticalSection(&rwlock->state_.num_readers_lock_);
-
-  /* Initialize the reader count. */
-  rwlock->state_.num_readers_ = 0;
-
-  return 0;
-}
-
-
-void uv_rwlock_destroy(uv_rwlock_t* rwlock) {
-  DeleteCriticalSection(&rwlock->state_.num_readers_lock_);
-  CloseHandle(rwlock->state_.write_semaphore_);
-}
-
-
-void uv_rwlock_rdlock(uv_rwlock_t* rwlock) {
-  /* Acquire the lock that protects the reader count. */
-  EnterCriticalSection(&rwlock->state_.num_readers_lock_);
-
-  /* Increase the reader count, and lock for write if this is the first
-   * reader.
-   */
-  if (++rwlock->state_.num_readers_ == 1) {
-    DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, INFINITE);
-    if (r != WAIT_OBJECT_0)
-      uv_fatal_error(GetLastError(), "WaitForSingleObject");
-  }
-
-  /* Release the lock that protects the reader count. */
-  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
-}
-
-
-int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
-  int err;
-
-  if (!TryEnterCriticalSection(&rwlock->state_.num_readers_lock_))
-    return UV_EBUSY;
-
-  err = 0;
-
-  if (rwlock->state_.num_readers_ == 0) {
-    /* Currently there are no other readers, which means that the write lock
-     * needs to be acquired.
-     */
-    DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, 0);
-    if (r == WAIT_OBJECT_0)
-      rwlock->state_.num_readers_++;
-    else if (r == WAIT_TIMEOUT)
-      err = UV_EBUSY;
-    else if (r == WAIT_FAILED)
-      uv_fatal_error(GetLastError(), "WaitForSingleObject");
-
-  } else {
-    /* The write lock has already been acquired because there are other
-     * active readers.
-     */
-    rwlock->state_.num_readers_++;
-  }
-
-  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
-  return err;
-}
-
-
-void uv_rwlock_rdunlock(uv_rwlock_t* rwlock) {
-  EnterCriticalSection(&rwlock->state_.num_readers_lock_);
-
-  if (--rwlock->state_.num_readers_ == 0) {
-    if (!ReleaseSemaphore(rwlock->state_.write_semaphore_, 1, NULL))
-      uv_fatal_error(GetLastError(), "ReleaseSemaphore");
-  }
-
-  LeaveCriticalSection(&rwlock->state_.num_readers_lock_);
-}
-
-
-void uv_rwlock_wrlock(uv_rwlock_t* rwlock) {
-  DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, INFINITE);
-  if (r != WAIT_OBJECT_0)
-    uv_fatal_error(GetLastError(), "WaitForSingleObject");
-}
-
-
-int uv_rwlock_trywrlock(uv_rwlock_t* rwlock) {
-  DWORD r = WaitForSingleObject(rwlock->state_.write_semaphore_, 0);
-  if (r == WAIT_OBJECT_0)
-    return 0;
-  else if (r == WAIT_TIMEOUT)
-    return UV_EBUSY;
-  else
-    uv_fatal_error(GetLastError(), "WaitForSingleObject");
-}
-
-
-void uv_rwlock_wrunlock(uv_rwlock_t* rwlock) {
-  if (!ReleaseSemaphore(rwlock->state_.write_semaphore_, 1, NULL))
-    uv_fatal_error(GetLastError(), "ReleaseSemaphore");
-}
-
-
-int uv_sem_init(uv_sem_t* sem, unsigned int value) {
-  *sem = CreateSemaphore(NULL, value, INT_MAX, NULL);
-  if (*sem == NULL)
-    return uv_translate_sys_error(GetLastError());
-  else
-    return 0;
-}
-
-
-void uv_sem_destroy(uv_sem_t* sem) {
-  if (!CloseHandle(*sem))
-    abort();
-}
-
-
-void uv_sem_post(uv_sem_t* sem) {
-  if (!ReleaseSemaphore(*sem, 1, NULL))
-    abort();
-}
-
-
-void uv_sem_wait(uv_sem_t* sem) {
-  if (WaitForSingleObject(*sem, INFINITE) != WAIT_OBJECT_0)
-    abort();
-}
-
-
-int uv_sem_trywait(uv_sem_t* sem) {
-  DWORD r = WaitForSingleObject(*sem, 0);
-
-  if (r == WAIT_OBJECT_0)
-    return 0;
-
-  if (r == WAIT_TIMEOUT)
-    return UV_EAGAIN;
-
-  abort();
-  return -1; /* Satisfy the compiler. */
-}
-
-
-int uv_cond_init(uv_cond_t* cond) {
-  InitializeConditionVariable(&cond->cond_var);
-  return 0;
-}
-
-
-void uv_cond_destroy(uv_cond_t* cond) {
-  /* nothing to do */
-  (void) &cond;
-}
-
-
-void uv_cond_signal(uv_cond_t* cond) {
-  WakeConditionVariable(&cond->cond_var);
-}
-
-
-void uv_cond_broadcast(uv_cond_t* cond) {
-  WakeAllConditionVariable(&cond->cond_var);
-}
-
-
-void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) {
-  if (!SleepConditionVariableCS(&cond->cond_var, mutex, INFINITE))
-    abort();
-}
-
-int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) {
-  if (SleepConditionVariableCS(&cond->cond_var, mutex, (DWORD)(timeout / 1e6)))
-    return 0;
-  if (GetLastError() != ERROR_TIMEOUT)
-    abort();
-  return UV_ETIMEDOUT;
-}
-
-
-int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {
-  int err;
-
-  barrier->n = count;
-  barrier->count = 0;
-
-  err = uv_mutex_init(&barrier->mutex);
-  if (err)
-    return err;
-
-  err = uv_sem_init(&barrier->turnstile1, 0);
-  if (err)
-    goto error2;
-
-  err = uv_sem_init(&barrier->turnstile2, 1);
-  if (err)
-    goto error;
-
-  return 0;
-
-error:
-  uv_sem_destroy(&barrier->turnstile1);
-error2:
-  uv_mutex_destroy(&barrier->mutex);
-  return err;
-
-}
-
-
-void uv_barrier_destroy(uv_barrier_t* barrier) {
-  uv_sem_destroy(&barrier->turnstile2);
-  uv_sem_destroy(&barrier->turnstile1);
-  uv_mutex_destroy(&barrier->mutex);
-}
-
-
-int uv_barrier_wait(uv_barrier_t* barrier) {
-  int serial_thread;
-
-  uv_mutex_lock(&barrier->mutex);
-  if (++barrier->count == barrier->n) {
-    uv_sem_wait(&barrier->turnstile2);
-    uv_sem_post(&barrier->turnstile1);
-  }
-  uv_mutex_unlock(&barrier->mutex);
-
-  uv_sem_wait(&barrier->turnstile1);
-  uv_sem_post(&barrier->turnstile1);
-
-  uv_mutex_lock(&barrier->mutex);
-  serial_thread = (--barrier->count == 0);
-  if (serial_thread) {
-    uv_sem_wait(&barrier->turnstile1);
-    uv_sem_post(&barrier->turnstile2);
-  }
-  uv_mutex_unlock(&barrier->mutex);
-
-  uv_sem_wait(&barrier->turnstile2);
-  uv_sem_post(&barrier->turnstile2);
-  return serial_thread;
-}
-
-
-int uv_key_create(uv_key_t* key) {
-  key->tls_index = TlsAlloc();
-  if (key->tls_index == TLS_OUT_OF_INDEXES)
-    return UV_ENOMEM;
-  return 0;
-}
-
-
-void uv_key_delete(uv_key_t* key) {
-  if (TlsFree(key->tls_index) == FALSE)
-    abort();
-  key->tls_index = TLS_OUT_OF_INDEXES;
-}
-
-
-void* uv_key_get(uv_key_t* key) {
-  void* value;
-
-  value = TlsGetValue(key->tls_index);
-  if (value == NULL)
-    if (GetLastError() != ERROR_SUCCESS)
-      abort();
-
-  return value;
-}
-
-
-void uv_key_set(uv_key_t* key, void* value) {
-  if (TlsSetValue(key->tls_index, value) == FALSE)
-    abort();
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/tty.cpp b/wpiutil/src/main/native/libuv/src/win/tty.cpp
deleted file mode 100644
index e4d7ac9..0000000
--- a/wpiutil/src/main/native/libuv/src/win/tty.cpp
+++ /dev/null
@@ -1,2335 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#define _CRT_NONSTDC_NO_WARNINGS
-
-#include <assert.h>
-#include <io.h>
-#include <string.h>
-#include <stdlib.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1600
-# include "uv/stdint-msvc2008.h"
-#else
-# include <stdint.h>
-#endif
-
-#ifndef COMMON_LVB_REVERSE_VIDEO
-# define COMMON_LVB_REVERSE_VIDEO 0x4000
-#endif
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "stream-inl.h"
-#include "req-inl.h"
-
-#pragma comment(lib, "User32.lib")
-
-#ifndef InterlockedOr
-# define InterlockedOr _InterlockedOr
-#endif
-
-#define UNICODE_REPLACEMENT_CHARACTER (0xfffd)
-
-#define ANSI_NORMAL           0x00
-#define ANSI_ESCAPE_SEEN      0x02
-#define ANSI_CSI              0x04
-#define ANSI_ST_CONTROL       0x08
-#define ANSI_IGNORE           0x10
-#define ANSI_IN_ARG           0x20
-#define ANSI_IN_STRING        0x40
-#define ANSI_BACKSLASH_SEEN   0x80
-
-#define MAX_INPUT_BUFFER_LENGTH 8192
-#define MAX_CONSOLE_CHAR 8192
-
-#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
-#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
-#endif
-
-static void uv_tty_capture_initial_style(CONSOLE_SCREEN_BUFFER_INFO* info);
-static void uv_tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info);
-static int uv__cancel_read_console(uv_tty_t* handle);
-
-
-/* Null uv_buf_t */
-static const uv_buf_t uv_null_buf_ = { 0, NULL };
-
-enum uv__read_console_status_e {
-  NOT_STARTED,
-  IN_PROGRESS,
-  TRAP_REQUESTED,
-  COMPLETED
-};
-
-static volatile LONG uv__read_console_status = NOT_STARTED;
-static volatile LONG uv__restore_screen_state;
-static CONSOLE_SCREEN_BUFFER_INFO uv__saved_screen_state;
-
-
-/*
- * The console virtual window.
- *
- * Normally cursor movement in windows is relative to the console screen buffer,
- * e.g. the application is allowed to overwrite the 'history'. This is very
- * inconvenient, it makes absolute cursor movement pretty useless. There is
- * also the concept of 'client rect' which is defined by the actual size of
- * the console window and the scroll position of the screen buffer, but it's
- * very volatile because it changes when the user scrolls.
- *
- * To make cursor movement behave sensibly we define a virtual window to which
- * cursor movement is confined. The virtual window is always as wide as the
- * console screen buffer, but it's height is defined by the size of the
- * console window. The top of the virtual window aligns with the position
- * of the caret when the first stdout/err handle is created, unless that would
- * mean that it would extend beyond the bottom of the screen buffer -  in that
- * that case it's located as far down as possible.
- *
- * When the user writes a long text or many newlines, such that the output
- * reaches beyond the bottom of the virtual window, the virtual window is
- * shifted downwards, but not resized.
- *
- * Since all tty i/o happens on the same console, this window is shared
- * between all stdout/stderr handles.
- */
-
-static int uv_tty_virtual_offset = -1;
-static int uv_tty_virtual_height = -1;
-static int uv_tty_virtual_width = -1;
-
-/* The console window size
- * We keep this separate from uv_tty_virtual_*. We use those values to only
- * handle signalling SIGWINCH
- */
-
-static HANDLE uv__tty_console_handle = INVALID_HANDLE_VALUE;
-static int uv__tty_console_height = -1;
-static int uv__tty_console_width = -1;
-
-static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param);
-static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook,
-                                                  DWORD event,
-                                                  HWND hwnd,
-                                                  LONG idObject,
-                                                  LONG idChild,
-                                                  DWORD dwEventThread,
-                                                  DWORD dwmsEventTime);
-
-/* We use a semaphore rather than a mutex or critical section because in some
-   cases (uv__cancel_read_console) we need take the lock in the main thread and
-   release it in another thread. Using a semaphore ensures that in such
-   scenario the main thread will still block when trying to acquire the lock. */
-static uv_sem_t uv_tty_output_lock;
-
-static WORD uv_tty_default_text_attributes =
-    FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
-
-static char uv_tty_default_fg_color = 7;
-static char uv_tty_default_bg_color = 0;
-static char uv_tty_default_fg_bright = 0;
-static char uv_tty_default_bg_bright = 0;
-static char uv_tty_default_inverse = 0;
-
-typedef enum {
-  UV_SUPPORTED,
-  UV_UNCHECKED,
-  UV_UNSUPPORTED
-} uv_vtermstate_t;
-/* Determine whether or not ANSI support is enabled. */
-static uv_vtermstate_t uv__vterm_state = UV_UNCHECKED;
-static void uv__determine_vterm_state(HANDLE handle);
-
-void uv_console_init(void) {
-  if (uv_sem_init(&uv_tty_output_lock, 1))
-    abort();
-  uv__tty_console_handle = CreateFileW(L"CONOUT$",
-                                       GENERIC_READ | GENERIC_WRITE,
-                                       FILE_SHARE_WRITE,
-                                       0,
-                                       OPEN_EXISTING,
-                                       0,
-                                       0);
-  if (uv__tty_console_handle != INVALID_HANDLE_VALUE) {
-    QueueUserWorkItem(uv__tty_console_resize_message_loop_thread,
-                      NULL,
-                      WT_EXECUTELONGFUNCTION);
-  }
-}
-
-
-int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, uv_file fd, int unused) {
-  BOOL readable;
-  DWORD NumberOfEvents;
-  HANDLE handle;
-  CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
-  (void)unused;
-
-  uv__once_init();
-  handle = (HANDLE) uv__get_osfhandle(fd);
-  if (handle == INVALID_HANDLE_VALUE)
-    return UV_EBADF;
-
-  if (fd <= 2) {
-    /* In order to avoid closing a stdio file descriptor 0-2, duplicate the
-     * underlying OS handle and forget about the original fd.
-     * We could also opt to use the original OS handle and just never close it,
-     * but then there would be no reliable way to cancel pending read operations
-     * upon close.
-     */
-    if (!DuplicateHandle(INVALID_HANDLE_VALUE,
-                         handle,
-                         INVALID_HANDLE_VALUE,
-                         &handle,
-                         0,
-                         FALSE,
-                         DUPLICATE_SAME_ACCESS))
-      return uv_translate_sys_error(GetLastError());
-    fd = -1;
-  }
-
-  readable = GetNumberOfConsoleInputEvents(handle, &NumberOfEvents);
-  if (!readable) {
-    /* Obtain the screen buffer info with the output handle. */
-    if (!GetConsoleScreenBufferInfo(handle, &screen_buffer_info)) {
-      return uv_translate_sys_error(GetLastError());
-    }
-
-    /* Obtain the tty_output_lock because the virtual window state is shared
-     * between all uv_tty_t handles. */
-    uv_sem_wait(&uv_tty_output_lock);
-
-    if (uv__vterm_state == UV_UNCHECKED)
-      uv__determine_vterm_state(handle);
-
-    /* Remember the original console text attributes. */
-    uv_tty_capture_initial_style(&screen_buffer_info);
-
-    uv_tty_update_virtual_window(&screen_buffer_info);
-
-    uv_sem_post(&uv_tty_output_lock);
-  }
-
-
-  uv_stream_init(loop, (uv_stream_t*) tty, UV_TTY);
-  uv_connection_init((uv_stream_t*) tty);
-
-  tty->handle = handle;
-  tty->u.fd = fd;
-  tty->reqs_pending = 0;
-  tty->flags |= UV_HANDLE_BOUND;
-
-  if (readable) {
-    /* Initialize TTY input specific fields. */
-    tty->flags |= UV_HANDLE_TTY_READABLE | UV_HANDLE_READABLE;
-    /* TODO: remove me in v2.x. */
-    tty->tty.rd.unused_ = NULL;
-    tty->tty.rd.read_line_buffer = uv_null_buf_;
-    tty->tty.rd.read_raw_wait = NULL;
-
-    /* Init keycode-to-vt100 mapper state. */
-    tty->tty.rd.last_key_len = 0;
-    tty->tty.rd.last_key_offset = 0;
-    tty->tty.rd.last_utf16_high_surrogate = 0;
-    memset(&tty->tty.rd.last_input_record, 0, sizeof tty->tty.rd.last_input_record);
-  } else {
-    /* TTY output specific fields. */
-    tty->flags |= UV_HANDLE_WRITABLE;
-
-    /* Init utf8-to-utf16 conversion state. */
-    tty->tty.wr.utf8_bytes_left = 0;
-    tty->tty.wr.utf8_codepoint = 0;
-
-    /* Initialize eol conversion state */
-    tty->tty.wr.previous_eol = 0;
-
-    /* Init ANSI parser state. */
-    tty->tty.wr.ansi_parser_state = ANSI_NORMAL;
-  }
-
-  return 0;
-}
-
-
-/* Set the default console text attributes based on how the console was
- * configured when libuv started.
- */
-static void uv_tty_capture_initial_style(CONSOLE_SCREEN_BUFFER_INFO* info) {
-  static int style_captured = 0;
-
-  /* Only do this once.
-     Assumption: Caller has acquired uv_tty_output_lock. */
-  if (style_captured)
-    return;
-
-  /* Save raw win32 attributes. */
-  uv_tty_default_text_attributes = info->wAttributes;
-
-  /* Convert black text on black background to use white text. */
-  if (uv_tty_default_text_attributes == 0)
-    uv_tty_default_text_attributes = 7;
-
-  /* Convert Win32 attributes to ANSI colors. */
-  uv_tty_default_fg_color = 0;
-  uv_tty_default_bg_color = 0;
-  uv_tty_default_fg_bright = 0;
-  uv_tty_default_bg_bright = 0;
-  uv_tty_default_inverse = 0;
-
-  if (uv_tty_default_text_attributes & FOREGROUND_RED)
-    uv_tty_default_fg_color |= 1;
-
-  if (uv_tty_default_text_attributes & FOREGROUND_GREEN)
-    uv_tty_default_fg_color |= 2;
-
-  if (uv_tty_default_text_attributes & FOREGROUND_BLUE)
-    uv_tty_default_fg_color |= 4;
-
-  if (uv_tty_default_text_attributes & BACKGROUND_RED)
-    uv_tty_default_bg_color |= 1;
-
-  if (uv_tty_default_text_attributes & BACKGROUND_GREEN)
-    uv_tty_default_bg_color |= 2;
-
-  if (uv_tty_default_text_attributes & BACKGROUND_BLUE)
-    uv_tty_default_bg_color |= 4;
-
-  if (uv_tty_default_text_attributes & FOREGROUND_INTENSITY)
-    uv_tty_default_fg_bright = 1;
-
-  if (uv_tty_default_text_attributes & BACKGROUND_INTENSITY)
-    uv_tty_default_bg_bright = 1;
-
-  if (uv_tty_default_text_attributes & COMMON_LVB_REVERSE_VIDEO)
-    uv_tty_default_inverse = 1;
-
-  style_captured = 1;
-}
-
-
-int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) {
-  DWORD flags;
-  unsigned char was_reading;
-  uv_alloc_cb alloc_cb;
-  uv_read_cb read_cb;
-  int err;
-
-  if (!(tty->flags & UV_HANDLE_TTY_READABLE)) {
-    return UV_EINVAL;
-  }
-
-  if (!!mode == !!(tty->flags & UV_HANDLE_TTY_RAW)) {
-    return 0;
-  }
-
-  switch (mode) {
-    case UV_TTY_MODE_NORMAL:
-      flags = ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
-      break;
-    case UV_TTY_MODE_RAW:
-      flags = ENABLE_WINDOW_INPUT;
-      break;
-    case UV_TTY_MODE_IO:
-      return UV_ENOTSUP;
-    default:
-      return UV_EINVAL;
-  }
-
-  /* If currently reading, stop, and restart reading. */
-  if (tty->flags & UV_HANDLE_READING) {
-    was_reading = 1;
-    alloc_cb = tty->alloc_cb;
-    read_cb = tty->read_cb;
-    err = uv_tty_read_stop(tty);
-    if (err) {
-      return uv_translate_sys_error(err);
-    }
-  } else {
-    was_reading = 0;
-    alloc_cb = NULL;
-    read_cb = NULL;
-  }
-
-  uv_sem_wait(&uv_tty_output_lock);
-  if (!SetConsoleMode(tty->handle, flags)) {
-    err = uv_translate_sys_error(GetLastError());
-    uv_sem_post(&uv_tty_output_lock);
-    return err;
-  }
-  uv_sem_post(&uv_tty_output_lock);
-
-  /* Update flag. */
-  tty->flags &= ~UV_HANDLE_TTY_RAW;
-  tty->flags |= mode ? UV_HANDLE_TTY_RAW : 0;
-
-  /* If we just stopped reading, restart. */
-  if (was_reading) {
-    err = uv_tty_read_start(tty, alloc_cb, read_cb);
-    if (err) {
-      return uv_translate_sys_error(err);
-    }
-  }
-
-  return 0;
-}
-
-
-int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
-  CONSOLE_SCREEN_BUFFER_INFO info;
-
-  if (!GetConsoleScreenBufferInfo(tty->handle, &info)) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  uv_sem_wait(&uv_tty_output_lock);
-  uv_tty_update_virtual_window(&info);
-  uv_sem_post(&uv_tty_output_lock);
-
-  *width = uv_tty_virtual_width;
-  *height = uv_tty_virtual_height;
-
-  return 0;
-}
-
-
-static void CALLBACK uv_tty_post_raw_read(void* data, BOOLEAN didTimeout) {
-  uv_loop_t* loop;
-  uv_tty_t* handle;
-  uv_req_t* req;
-
-  assert(data);
-  assert(!didTimeout);
-
-  req = (uv_req_t*) data;
-  handle = (uv_tty_t*) req->data;
-  loop = handle->loop;
-
-  UnregisterWait(handle->tty.rd.read_raw_wait);
-  handle->tty.rd.read_raw_wait = NULL;
-
-  SET_REQ_SUCCESS(req);
-  POST_COMPLETION_FOR_REQ(loop, req);
-}
-
-
-static void uv_tty_queue_read_raw(uv_loop_t* loop, uv_tty_t* handle) {
-  uv_read_t* req;
-  BOOL r;
-
-  assert(handle->flags & UV_HANDLE_READING);
-  assert(!(handle->flags & UV_HANDLE_READ_PENDING));
-
-  assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
-
-  handle->tty.rd.read_line_buffer = uv_null_buf_;
-
-  req = &handle->read_req;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  r = RegisterWaitForSingleObject(&handle->tty.rd.read_raw_wait,
-                                  handle->handle,
-                                  uv_tty_post_raw_read,
-                                  (void*) req,
-                                  INFINITE,
-                                  WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
-  if (!r) {
-    handle->tty.rd.read_raw_wait = NULL;
-    SET_REQ_ERROR(req, GetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  }
-
-  handle->flags |= UV_HANDLE_READ_PENDING;
-  handle->reqs_pending++;
-}
-
-
-static DWORD CALLBACK uv_tty_line_read_thread(void* data) {
-  uv_loop_t* loop;
-  uv_tty_t* handle;
-  uv_req_t* req;
-  DWORD bytes, read_bytes;
-  WCHAR utf16[MAX_INPUT_BUFFER_LENGTH / 3];
-  DWORD chars, read_chars;
-  LONG status;
-  COORD pos;
-  BOOL read_console_success;
-
-  assert(data);
-
-  req = (uv_req_t*) data;
-  handle = (uv_tty_t*) req->data;
-  loop = handle->loop;
-
-  assert(handle->tty.rd.read_line_buffer.base != NULL);
-  assert(handle->tty.rd.read_line_buffer.len > 0);
-
-  /* ReadConsole can't handle big buffers. */
-  if (handle->tty.rd.read_line_buffer.len < MAX_INPUT_BUFFER_LENGTH) {
-    bytes = handle->tty.rd.read_line_buffer.len;
-  } else {
-    bytes = MAX_INPUT_BUFFER_LENGTH;
-  }
-
-  /* At last, unicode! One utf-16 codeunit never takes more than 3 utf-8
-   * codeunits to encode. */
-  chars = bytes / 3;
-
-  status = InterlockedExchange(&uv__read_console_status, IN_PROGRESS);
-  if (status == TRAP_REQUESTED) {
-    SET_REQ_SUCCESS(req);
-    req->u.io.overlapped.InternalHigh = 0;
-    POST_COMPLETION_FOR_REQ(loop, req);
-    return 0;
-  }
-
-  read_console_success = ReadConsoleW(handle->handle,
-                                      (void*) utf16,
-                                      chars,
-                                      &read_chars,
-                                      NULL);
-
-  if (read_console_success) {
-    read_bytes = WideCharToMultiByte(CP_UTF8,
-                                     0,
-                                     utf16,
-                                     read_chars,
-                                     handle->tty.rd.read_line_buffer.base,
-                                     bytes,
-                                     NULL,
-                                     NULL);
-    SET_REQ_SUCCESS(req);
-    req->u.io.overlapped.InternalHigh = read_bytes;
-  } else {
-    SET_REQ_ERROR(req, GetLastError());
-  }
-
-  status = InterlockedExchange(&uv__read_console_status, COMPLETED);
-
-  if (status ==  TRAP_REQUESTED) {
-    /* If we canceled the read by sending a VK_RETURN event, restore the
-       screen state to undo the visual effect of the VK_RETURN */
-    if (read_console_success && InterlockedOr(&uv__restore_screen_state, 0)) {
-      HANDLE active_screen_buffer;
-      active_screen_buffer = CreateFileA("conout$",
-                                         GENERIC_READ | GENERIC_WRITE,
-                                         FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                         NULL,
-                                         OPEN_EXISTING,
-                                         FILE_ATTRIBUTE_NORMAL,
-                                         NULL);
-      if (active_screen_buffer != INVALID_HANDLE_VALUE) {
-        pos = uv__saved_screen_state.dwCursorPosition;
-
-        /* If the cursor was at the bottom line of the screen buffer, the
-           VK_RETURN would have caused the buffer contents to scroll up by one
-           line. The right position to reset the cursor to is therefore one line
-           higher */
-        if (pos.Y == uv__saved_screen_state.dwSize.Y - 1)
-          pos.Y--;
-
-        SetConsoleCursorPosition(active_screen_buffer, pos);
-        CloseHandle(active_screen_buffer);
-      }
-    }
-    uv_sem_post(&uv_tty_output_lock);
-  }
-  POST_COMPLETION_FOR_REQ(loop, req);
-  return 0;
-}
-
-
-static void uv_tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) {
-  uv_read_t* req;
-  BOOL r;
-
-  assert(handle->flags & UV_HANDLE_READING);
-  assert(!(handle->flags & UV_HANDLE_READ_PENDING));
-  assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
-
-  req = &handle->read_req;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  handle->tty.rd.read_line_buffer = uv_buf_init(NULL, 0);
-  handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->tty.rd.read_line_buffer);
-  if (handle->tty.rd.read_line_buffer.base == NULL ||
-      handle->tty.rd.read_line_buffer.len == 0) {
-    handle->read_cb((uv_stream_t*) handle,
-                    UV_ENOBUFS,
-                    &handle->tty.rd.read_line_buffer);
-    return;
-  }
-  assert(handle->tty.rd.read_line_buffer.base != NULL);
-
-  /* Reset flags  No locking is required since there cannot be a line read
-     in progress. We are also relying on the memory barrier provided by
-     QueueUserWorkItem*/
-  uv__restore_screen_state = FALSE;
-  uv__read_console_status = NOT_STARTED;
-  r = QueueUserWorkItem(uv_tty_line_read_thread,
-                        (void*) req,
-                        WT_EXECUTELONGFUNCTION);
-  if (!r) {
-    SET_REQ_ERROR(req, GetLastError());
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  }
-
-  handle->flags |= UV_HANDLE_READ_PENDING;
-  handle->reqs_pending++;
-}
-
-
-static void uv_tty_queue_read(uv_loop_t* loop, uv_tty_t* handle) {
-  if (handle->flags & UV_HANDLE_TTY_RAW) {
-    uv_tty_queue_read_raw(loop, handle);
-  } else {
-    uv_tty_queue_read_line(loop, handle);
-  }
-}
-
-
-static const char* get_vt100_fn_key(DWORD code, char shift, char ctrl,
-    size_t* len) {
-#define VK_CASE(vk, normal_str, shift_str, ctrl_str, shift_ctrl_str)          \
-    case (vk):                                                                \
-      if (shift && ctrl) {                                                    \
-        *len = sizeof shift_ctrl_str;                                         \
-        return "\033" shift_ctrl_str;                                         \
-      } else if (shift) {                                                     \
-        *len = sizeof shift_str ;                                             \
-        return "\033" shift_str;                                              \
-      } else if (ctrl) {                                                      \
-        *len = sizeof ctrl_str;                                               \
-        return "\033" ctrl_str;                                               \
-      } else {                                                                \
-        *len = sizeof normal_str;                                             \
-        return "\033" normal_str;                                             \
-      }
-
-  switch (code) {
-    /* These mappings are the same as Cygwin's. Unmodified and alt-modified
-     * keypad keys comply with linux console, modifiers comply with xterm
-     * modifier usage. F1. f12 and shift-f1. f10 comply with linux console, f6.
-     * f12 with and without modifiers comply with rxvt. */
-    VK_CASE(VK_INSERT,  "[2~",  "[2;2~", "[2;5~", "[2;6~")
-    VK_CASE(VK_END,     "[4~",  "[4;2~", "[4;5~", "[4;6~")
-    VK_CASE(VK_DOWN,    "[B",   "[1;2B", "[1;5B", "[1;6B")
-    VK_CASE(VK_NEXT,    "[6~",  "[6;2~", "[6;5~", "[6;6~")
-    VK_CASE(VK_LEFT,    "[D",   "[1;2D", "[1;5D", "[1;6D")
-    VK_CASE(VK_CLEAR,   "[G",   "[1;2G", "[1;5G", "[1;6G")
-    VK_CASE(VK_RIGHT,   "[C",   "[1;2C", "[1;5C", "[1;6C")
-    VK_CASE(VK_UP,      "[A",   "[1;2A", "[1;5A", "[1;6A")
-    VK_CASE(VK_HOME,    "[1~",  "[1;2~", "[1;5~", "[1;6~")
-    VK_CASE(VK_PRIOR,   "[5~",  "[5;2~", "[5;5~", "[5;6~")
-    VK_CASE(VK_DELETE,  "[3~",  "[3;2~", "[3;5~", "[3;6~")
-    VK_CASE(VK_NUMPAD0, "[2~",  "[2;2~", "[2;5~", "[2;6~")
-    VK_CASE(VK_NUMPAD1, "[4~",  "[4;2~", "[4;5~", "[4;6~")
-    VK_CASE(VK_NUMPAD2, "[B",   "[1;2B", "[1;5B", "[1;6B")
-    VK_CASE(VK_NUMPAD3, "[6~",  "[6;2~", "[6;5~", "[6;6~")
-    VK_CASE(VK_NUMPAD4, "[D",   "[1;2D", "[1;5D", "[1;6D")
-    VK_CASE(VK_NUMPAD5, "[G",   "[1;2G", "[1;5G", "[1;6G")
-    VK_CASE(VK_NUMPAD6, "[C",   "[1;2C", "[1;5C", "[1;6C")
-    VK_CASE(VK_NUMPAD7, "[A",   "[1;2A", "[1;5A", "[1;6A")
-    VK_CASE(VK_NUMPAD8, "[1~",  "[1;2~", "[1;5~", "[1;6~")
-    VK_CASE(VK_NUMPAD9, "[5~",  "[5;2~", "[5;5~", "[5;6~")
-    VK_CASE(VK_DECIMAL, "[3~",  "[3;2~", "[3;5~", "[3;6~")
-    VK_CASE(VK_F1,      "[[A",  "[23~",  "[11^",  "[23^" )
-    VK_CASE(VK_F2,      "[[B",  "[24~",  "[12^",  "[24^" )
-    VK_CASE(VK_F3,      "[[C",  "[25~",  "[13^",  "[25^" )
-    VK_CASE(VK_F4,      "[[D",  "[26~",  "[14^",  "[26^" )
-    VK_CASE(VK_F5,      "[[E",  "[28~",  "[15^",  "[28^" )
-    VK_CASE(VK_F6,      "[17~", "[29~",  "[17^",  "[29^" )
-    VK_CASE(VK_F7,      "[18~", "[31~",  "[18^",  "[31^" )
-    VK_CASE(VK_F8,      "[19~", "[32~",  "[19^",  "[32^" )
-    VK_CASE(VK_F9,      "[20~", "[33~",  "[20^",  "[33^" )
-    VK_CASE(VK_F10,     "[21~", "[34~",  "[21^",  "[34^" )
-    VK_CASE(VK_F11,     "[23~", "[23$",  "[23^",  "[23@" )
-    VK_CASE(VK_F12,     "[24~", "[24$",  "[24^",  "[24@" )
-
-    default:
-      *len = 0;
-      return NULL;
-  }
-#undef VK_CASE
-}
-
-
-void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* req) {
-  /* Shortcut for handle->tty.rd.last_input_record.Event.KeyEvent. */
-#define KEV handle->tty.rd.last_input_record.Event.KeyEvent
-
-  DWORD records_left, records_read;
-  uv_buf_t buf;
-  off_t buf_used;
-
-  assert(handle->type == UV_TTY);
-  assert(handle->flags & UV_HANDLE_TTY_READABLE);
-  handle->flags &= ~UV_HANDLE_READ_PENDING;
-
-  if (!(handle->flags & UV_HANDLE_READING) ||
-      !(handle->flags & UV_HANDLE_TTY_RAW)) {
-    goto out;
-  }
-
-  if (!REQ_SUCCESS(req)) {
-    /* An error occurred while waiting for the event. */
-    if ((handle->flags & UV_HANDLE_READING)) {
-      handle->flags &= ~UV_HANDLE_READING;
-      handle->read_cb((uv_stream_t*)handle,
-                      uv_translate_sys_error(GET_REQ_ERROR(req)),
-                      &uv_null_buf_);
-    }
-    goto out;
-  }
-
-  /* Fetch the number of events  */
-  if (!GetNumberOfConsoleInputEvents(handle->handle, &records_left)) {
-    handle->flags &= ~UV_HANDLE_READING;
-    DECREASE_ACTIVE_COUNT(loop, handle);
-    handle->read_cb((uv_stream_t*)handle,
-                    uv_translate_sys_error(GetLastError()),
-                    &uv_null_buf_);
-    goto out;
-  }
-
-  /* Windows sends a lot of events that we're not interested in, so buf will be
-   * allocated on demand, when there's actually something to emit. */
-  buf = uv_null_buf_;
-  buf_used = 0;
-
-  while ((records_left > 0 || handle->tty.rd.last_key_len > 0) &&
-         (handle->flags & UV_HANDLE_READING)) {
-    if (handle->tty.rd.last_key_len == 0) {
-      /* Read the next input record */
-      if (!ReadConsoleInputW(handle->handle,
-                             &handle->tty.rd.last_input_record,
-                             1,
-                             &records_read)) {
-        handle->flags &= ~UV_HANDLE_READING;
-        DECREASE_ACTIVE_COUNT(loop, handle);
-        handle->read_cb((uv_stream_t*) handle,
-                        uv_translate_sys_error(GetLastError()),
-                        &buf);
-        goto out;
-      }
-      records_left--;
-
-      /* Ignore other events that are not key events. */
-      if (handle->tty.rd.last_input_record.EventType != KEY_EVENT) {
-        continue;
-      }
-
-      /* Ignore keyup events, unless the left alt key was held and a valid
-       * unicode character was emitted. */
-      if (!KEV.bKeyDown &&
-          (KEV.wVirtualKeyCode != VK_MENU ||
-           KEV.uChar.UnicodeChar == 0)) {
-        continue;
-      }
-
-      /* Ignore keypresses to numpad number keys if the left alt is held
-       * because the user is composing a character, or windows simulating this.
-       */
-      if ((KEV.dwControlKeyState & LEFT_ALT_PRESSED) &&
-          !(KEV.dwControlKeyState & ENHANCED_KEY) &&
-          (KEV.wVirtualKeyCode == VK_INSERT ||
-          KEV.wVirtualKeyCode == VK_END ||
-          KEV.wVirtualKeyCode == VK_DOWN ||
-          KEV.wVirtualKeyCode == VK_NEXT ||
-          KEV.wVirtualKeyCode == VK_LEFT ||
-          KEV.wVirtualKeyCode == VK_CLEAR ||
-          KEV.wVirtualKeyCode == VK_RIGHT ||
-          KEV.wVirtualKeyCode == VK_HOME ||
-          KEV.wVirtualKeyCode == VK_UP ||
-          KEV.wVirtualKeyCode == VK_PRIOR ||
-          KEV.wVirtualKeyCode == VK_NUMPAD0 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD1 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD2 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD3 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD4 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD5 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD6 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD7 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD8 ||
-          KEV.wVirtualKeyCode == VK_NUMPAD9)) {
-        continue;
-      }
-
-      if (KEV.uChar.UnicodeChar != 0) {
-        int prefix_len, char_len;
-
-        /* Character key pressed */
-        if (KEV.uChar.UnicodeChar >= 0xD800 &&
-            KEV.uChar.UnicodeChar < 0xDC00) {
-          /* UTF-16 high surrogate */
-          handle->tty.rd.last_utf16_high_surrogate = KEV.uChar.UnicodeChar;
-          continue;
-        }
-
-        /* Prefix with \u033 if alt was held, but alt was not used as part a
-         * compose sequence. */
-        if ((KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
-            && !(KEV.dwControlKeyState & (LEFT_CTRL_PRESSED |
-            RIGHT_CTRL_PRESSED)) && KEV.bKeyDown) {
-          handle->tty.rd.last_key[0] = '\033';
-          prefix_len = 1;
-        } else {
-          prefix_len = 0;
-        }
-
-        if (KEV.uChar.UnicodeChar >= 0xDC00 &&
-            KEV.uChar.UnicodeChar < 0xE000) {
-          /* UTF-16 surrogate pair */
-          WCHAR utf16_buffer[2];
-          utf16_buffer[0] = handle->tty.rd.last_utf16_high_surrogate;
-          utf16_buffer[1] = KEV.uChar.UnicodeChar;
-          char_len = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         utf16_buffer,
-                                         2,
-                                         &handle->tty.rd.last_key[prefix_len],
-                                         sizeof handle->tty.rd.last_key,
-                                         NULL,
-                                         NULL);
-        } else {
-          /* Single UTF-16 character */
-          char_len = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         &KEV.uChar.UnicodeChar,
-                                         1,
-                                         &handle->tty.rd.last_key[prefix_len],
-                                         sizeof handle->tty.rd.last_key,
-                                         NULL,
-                                         NULL);
-        }
-
-        /* Whatever happened, the last character wasn't a high surrogate. */
-        handle->tty.rd.last_utf16_high_surrogate = 0;
-
-        /* If the utf16 character(s) couldn't be converted something must be
-         * wrong. */
-        if (!char_len) {
-          handle->flags &= ~UV_HANDLE_READING;
-          DECREASE_ACTIVE_COUNT(loop, handle);
-          handle->read_cb((uv_stream_t*) handle,
-                          uv_translate_sys_error(GetLastError()),
-                          &buf);
-          goto out;
-        }
-
-        handle->tty.rd.last_key_len = (unsigned char) (prefix_len + char_len);
-        handle->tty.rd.last_key_offset = 0;
-        continue;
-
-      } else {
-        /* Function key pressed */
-        const char* vt100;
-        size_t prefix_len, vt100_len;
-
-        vt100 = get_vt100_fn_key(KEV.wVirtualKeyCode,
-                                  !!(KEV.dwControlKeyState & SHIFT_PRESSED),
-                                  !!(KEV.dwControlKeyState & (
-                                    LEFT_CTRL_PRESSED |
-                                    RIGHT_CTRL_PRESSED)),
-                                  &vt100_len);
-
-        /* If we were unable to map to a vt100 sequence, just ignore. */
-        if (!vt100) {
-          continue;
-        }
-
-        /* Prefix with \x033 when the alt key was held. */
-        if (KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
-          handle->tty.rd.last_key[0] = '\033';
-          prefix_len = 1;
-        } else {
-          prefix_len = 0;
-        }
-
-        /* Copy the vt100 sequence to the handle buffer. */
-        assert(prefix_len + vt100_len < sizeof handle->tty.rd.last_key);
-        memcpy(&handle->tty.rd.last_key[prefix_len], vt100, vt100_len);
-
-        handle->tty.rd.last_key_len = (unsigned char) (prefix_len + vt100_len);
-        handle->tty.rd.last_key_offset = 0;
-        continue;
-      }
-    } else {
-      /* Copy any bytes left from the last keypress to the user buffer. */
-      if (handle->tty.rd.last_key_offset < handle->tty.rd.last_key_len) {
-        /* Allocate a buffer if needed */
-        if (buf_used == 0) {
-          buf = uv_buf_init(NULL, 0);
-          handle->alloc_cb((uv_handle_t*) handle, 1024, &buf);
-          if (buf.base == NULL || buf.len == 0) {
-            handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
-            goto out;
-          }
-          assert(buf.base != NULL);
-        }
-
-        buf.base[buf_used++] = handle->tty.rd.last_key[handle->tty.rd.last_key_offset++];
-
-        /* If the buffer is full, emit it */
-        if ((size_t) buf_used == buf.len) {
-          handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
-          buf = uv_null_buf_;
-          buf_used = 0;
-        }
-
-        continue;
-      }
-
-      /* Apply dwRepeat from the last input record. */
-      if (--KEV.wRepeatCount > 0) {
-        handle->tty.rd.last_key_offset = 0;
-        continue;
-      }
-
-      handle->tty.rd.last_key_len = 0;
-      continue;
-    }
-  }
-
-  /* Send the buffer back to the user */
-  if (buf_used > 0) {
-    handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
-  }
-
- out:
-  /* Wait for more input events. */
-  if ((handle->flags & UV_HANDLE_READING) &&
-      !(handle->flags & UV_HANDLE_READ_PENDING)) {
-    uv_tty_queue_read(loop, handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-
-#undef KEV
-}
-
-
-
-void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* req) {
-  uv_buf_t buf;
-
-  assert(handle->type == UV_TTY);
-  assert(handle->flags & UV_HANDLE_TTY_READABLE);
-
-  buf = handle->tty.rd.read_line_buffer;
-
-  handle->flags &= ~UV_HANDLE_READ_PENDING;
-  handle->tty.rd.read_line_buffer = uv_null_buf_;
-
-  if (!REQ_SUCCESS(req)) {
-    /* Read was not successful */
-    if (handle->flags & UV_HANDLE_READING) {
-      /* Real error */
-      handle->flags &= ~UV_HANDLE_READING;
-      DECREASE_ACTIVE_COUNT(loop, handle);
-      handle->read_cb((uv_stream_t*) handle,
-                      uv_translate_sys_error(GET_REQ_ERROR(req)),
-                      &buf);
-    }
-  } else {
-    if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING) &&
-        req->u.io.overlapped.InternalHigh != 0) {
-      /* Read successful. TODO: read unicode, convert to utf-8 */
-      DWORD bytes = req->u.io.overlapped.InternalHigh;
-      handle->read_cb((uv_stream_t*) handle, bytes, &buf);
-    }
-    handle->flags &= ~UV_HANDLE_CANCELLATION_PENDING;
-  }
-
-  /* Wait for more input events. */
-  if ((handle->flags & UV_HANDLE_READING) &&
-      !(handle->flags & UV_HANDLE_READ_PENDING)) {
-    uv_tty_queue_read(loop, handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* req) {
-  assert(handle->type == UV_TTY);
-  assert(handle->flags & UV_HANDLE_TTY_READABLE);
-
-  /* If the read_line_buffer member is zero, it must have been an raw read.
-   * Otherwise it was a line-buffered read. FIXME: This is quite obscure. Use a
-   * flag or something. */
-  if (handle->tty.rd.read_line_buffer.len == 0) {
-    uv_process_tty_read_raw_req(loop, handle, req);
-  } else {
-    uv_process_tty_read_line_req(loop, handle, req);
-  }
-}
-
-
-int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
-    uv_read_cb read_cb) {
-  uv_loop_t* loop = handle->loop;
-
-  if (!(handle->flags & UV_HANDLE_TTY_READABLE)) {
-    return ERROR_INVALID_PARAMETER;
-  }
-
-  handle->flags |= UV_HANDLE_READING;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-  handle->read_cb = read_cb;
-  handle->alloc_cb = alloc_cb;
-
-  /* If reading was stopped and then started again, there could still be a read
-   * request pending. */
-  if (handle->flags & UV_HANDLE_READ_PENDING) {
-    return 0;
-  }
-
-  /* Maybe the user stopped reading half-way while processing key events.
-   * Short-circuit if this could be the case. */
-  if (handle->tty.rd.last_key_len > 0) {
-    SET_REQ_SUCCESS(&handle->read_req);
-    uv_insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req);
-    /* Make sure no attempt is made to insert it again until it's handled. */
-    handle->flags |= UV_HANDLE_READ_PENDING;
-    handle->reqs_pending++;
-    return 0;
-  }
-
-  uv_tty_queue_read(loop, handle);
-
-  return 0;
-}
-
-
-int uv_tty_read_stop(uv_tty_t* handle) {
-  INPUT_RECORD record;
-  DWORD written, err;
-
-  handle->flags &= ~UV_HANDLE_READING;
-  DECREASE_ACTIVE_COUNT(handle->loop, handle);
-
-  if (!(handle->flags & UV_HANDLE_READ_PENDING))
-    return 0;
-
-  if (handle->flags & UV_HANDLE_TTY_RAW) {
-    /* Cancel raw read. Write some bullshit event to force the console wait to
-     * return. */
-    memset(&record, 0, sizeof record);
-    record.EventType = FOCUS_EVENT;
-    if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
-      return GetLastError();
-    }
-  } else if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)) {
-    /* Cancel line-buffered read if not already pending */
-    err = uv__cancel_read_console(handle);
-    if (err)
-      return err;
-
-    handle->flags |= UV_HANDLE_CANCELLATION_PENDING;
-  }
-
-  return 0;
-}
-
-static int uv__cancel_read_console(uv_tty_t* handle) {
-  HANDLE active_screen_buffer = INVALID_HANDLE_VALUE;
-  INPUT_RECORD record;
-  DWORD written;
-  DWORD err = 0;
-  LONG status;
-
-  assert(!(handle->flags & UV_HANDLE_CANCELLATION_PENDING));
-
-  /* Hold the output lock during the cancellation, to ensure that further
-     writes don't interfere with the screen state. It will be the ReadConsole
-     thread's responsibility to release the lock. */
-  uv_sem_wait(&uv_tty_output_lock);
-  status = InterlockedExchange(&uv__read_console_status, TRAP_REQUESTED);
-  if (status != IN_PROGRESS) {
-    /* Either we have managed to set a trap for the other thread before
-       ReadConsole is called, or ReadConsole has returned because the user
-       has pressed ENTER. In either case, there is nothing else to do. */
-    uv_sem_post(&uv_tty_output_lock);
-    return 0;
-  }
-
-  /* Save screen state before sending the VK_RETURN event */
-  active_screen_buffer = CreateFileA("conout$",
-                                     GENERIC_READ | GENERIC_WRITE,
-                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                     NULL,
-                                     OPEN_EXISTING,
-                                     FILE_ATTRIBUTE_NORMAL,
-                                     NULL);
-
-  if (active_screen_buffer != INVALID_HANDLE_VALUE &&
-      GetConsoleScreenBufferInfo(active_screen_buffer,
-                                 &uv__saved_screen_state)) {
-    InterlockedOr(&uv__restore_screen_state, 1);
-  }
-
-  /* Write enter key event to force the console wait to return. */
-  record.EventType = KEY_EVENT;
-  record.Event.KeyEvent.bKeyDown = TRUE;
-  record.Event.KeyEvent.wRepeatCount = 1;
-  record.Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
-  record.Event.KeyEvent.wVirtualScanCode =
-    MapVirtualKeyW(VK_RETURN, MAPVK_VK_TO_VSC);
-  record.Event.KeyEvent.uChar.UnicodeChar = L'\r';
-  record.Event.KeyEvent.dwControlKeyState = 0;
-  if (!WriteConsoleInputW(handle->handle, &record, 1, &written))
-    err = GetLastError();
-
-  if (active_screen_buffer != INVALID_HANDLE_VALUE)
-    CloseHandle(active_screen_buffer);
-
-  return err;
-}
-
-
-static void uv_tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info) {
-  uv_tty_virtual_width = info->dwSize.X;
-  uv_tty_virtual_height = info->srWindow.Bottom - info->srWindow.Top + 1;
-
-  /* Recompute virtual window offset row. */
-  if (uv_tty_virtual_offset == -1) {
-    uv_tty_virtual_offset = info->dwCursorPosition.Y;
-  } else if (uv_tty_virtual_offset < info->dwCursorPosition.Y -
-             uv_tty_virtual_height + 1) {
-    /* If suddenly find the cursor outside of the virtual window, it must have
-     * somehow scrolled. Update the virtual window offset. */
-    uv_tty_virtual_offset = info->dwCursorPosition.Y -
-                            uv_tty_virtual_height + 1;
-  }
-  if (uv_tty_virtual_offset + uv_tty_virtual_height > info->dwSize.Y) {
-    uv_tty_virtual_offset = info->dwSize.Y - uv_tty_virtual_height;
-  }
-  if (uv_tty_virtual_offset < 0) {
-    uv_tty_virtual_offset = 0;
-  }
-}
-
-
-static COORD uv_tty_make_real_coord(uv_tty_t* handle,
-    CONSOLE_SCREEN_BUFFER_INFO* info, int x, unsigned char x_relative, int y,
-    unsigned char y_relative) {
-  COORD result;
-
-  uv_tty_update_virtual_window(info);
-
-  /* Adjust y position */
-  if (y_relative) {
-    y = info->dwCursorPosition.Y + y;
-  } else {
-    y = uv_tty_virtual_offset + y;
-  }
-  /* Clip y to virtual client rectangle */
-  if (y < uv_tty_virtual_offset) {
-    y = uv_tty_virtual_offset;
-  } else if (y >= uv_tty_virtual_offset + uv_tty_virtual_height) {
-    y = uv_tty_virtual_offset + uv_tty_virtual_height - 1;
-  }
-
-  /* Adjust x */
-  if (x_relative) {
-    x = info->dwCursorPosition.X + x;
-  }
-  /* Clip x */
-  if (x < 0) {
-    x = 0;
-  } else if (x >= uv_tty_virtual_width) {
-    x = uv_tty_virtual_width - 1;
-  }
-
-  result.X = (unsigned short) x;
-  result.Y = (unsigned short) y;
-  return result;
-}
-
-
-static int uv_tty_emit_text(uv_tty_t* handle, WCHAR buffer[], DWORD length,
-    DWORD* error) {
-  DWORD written;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
-  if (!WriteConsoleW(handle->handle,
-                     (void*) buffer,
-                     length,
-                     &written,
-                     NULL)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  return 0;
-}
-
-
-static int uv_tty_move_caret(uv_tty_t* handle, int x, unsigned char x_relative,
-    int y, unsigned char y_relative, DWORD* error) {
-  CONSOLE_SCREEN_BUFFER_INFO info;
-  COORD pos;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
- retry:
-  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-    *error = GetLastError();
-  }
-
-  pos = uv_tty_make_real_coord(handle, &info, x, x_relative, y, y_relative);
-
-  if (!SetConsoleCursorPosition(handle->handle, pos)) {
-    if (GetLastError() == ERROR_INVALID_PARAMETER) {
-      /* The console may be resized - retry */
-      goto retry;
-    } else {
-      *error = GetLastError();
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-
-static int uv_tty_reset(uv_tty_t* handle, DWORD* error) {
-  const COORD origin = {0, 0};
-  const WORD char_attrs = uv_tty_default_text_attributes;
-  CONSOLE_SCREEN_BUFFER_INFO info;
-  DWORD count, written;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
-  /* Reset original text attributes. */
-  if (!SetConsoleTextAttribute(handle->handle, char_attrs)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  /* Move the cursor position to (0, 0). */
-  if (!SetConsoleCursorPosition(handle->handle, origin)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  /* Clear the screen buffer. */
- retry:
-  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  count = info.dwSize.X * info.dwSize.Y;
-
-  if (!(FillConsoleOutputCharacterW(handle->handle,
-                                    L'\x20',
-                                    count,
-                                    origin,
-                                    &written) &&
-        FillConsoleOutputAttribute(handle->handle,
-                                   char_attrs,
-                                   written,
-                                   origin,
-                                   &written))) {
-    if (GetLastError() == ERROR_INVALID_PARAMETER) {
-      /* The console may be resized - retry */
-      goto retry;
-    } else {
-      *error = GetLastError();
-      return -1;
-    }
-  }
-
-  /* Move the virtual window up to the top. */
-  uv_tty_virtual_offset = 0;
-  uv_tty_update_virtual_window(&info);
-
-  return 0;
-}
-
-
-static int uv_tty_clear(uv_tty_t* handle, int dir, char entire_screen,
-    DWORD* error) {
-  CONSOLE_SCREEN_BUFFER_INFO info;
-  COORD start, end;
-  DWORD count, written;
-
-  int x1, x2, y1, y2;
-  int x1r, x2r, y1r, y2r;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
-  if (dir == 0) {
-    /* Clear from current position */
-    x1 = 0;
-    x1r = 1;
-  } else {
-    /* Clear from column 0 */
-    x1 = 0;
-    x1r = 0;
-  }
-
-  if (dir == 1) {
-    /* Clear to current position */
-    x2 = 0;
-    x2r = 1;
-  } else {
-    /* Clear to end of row. We pretend the console is 65536 characters wide,
-     * uv_tty_make_real_coord will clip it to the actual console width. */
-    x2 = 0xffff;
-    x2r = 0;
-  }
-
-  if (!entire_screen) {
-    /* Stay on our own row */
-    y1 = y2 = 0;
-    y1r = y2r = 1;
-  } else {
-    /* Apply columns direction to row */
-    y1 = x1;
-    y1r = x1r;
-    y2 = x2;
-    y2r = x2r;
-  }
-
- retry:
-  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  start = uv_tty_make_real_coord(handle, &info, x1, x1r, y1, y1r);
-  end = uv_tty_make_real_coord(handle, &info, x2, x2r, y2, y2r);
-  count = (end.Y * info.dwSize.X + end.X) -
-          (start.Y * info.dwSize.X + start.X) + 1;
-
-  if (!(FillConsoleOutputCharacterW(handle->handle,
-                              L'\x20',
-                              count,
-                              start,
-                              &written) &&
-        FillConsoleOutputAttribute(handle->handle,
-                                   info.wAttributes,
-                                   written,
-                                   start,
-                                   &written))) {
-    if (GetLastError() == ERROR_INVALID_PARAMETER) {
-      /* The console may be resized - retry */
-      goto retry;
-    } else {
-      *error = GetLastError();
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-#define FLIP_FGBG                                                             \
-    do {                                                                      \
-      WORD fg = info.wAttributes & 0xF;                                       \
-      WORD bg = info.wAttributes & 0xF0;                                      \
-      info.wAttributes &= 0xFF00;                                             \
-      info.wAttributes |= fg << 4;                                            \
-      info.wAttributes |= bg >> 4;                                            \
-    } while (0)
-
-static int uv_tty_set_style(uv_tty_t* handle, DWORD* error) {
-  unsigned short argc = handle->tty.wr.ansi_csi_argc;
-  unsigned short* argv = handle->tty.wr.ansi_csi_argv;
-  int i;
-  CONSOLE_SCREEN_BUFFER_INFO info;
-
-  char fg_color = -1, bg_color = -1;
-  char fg_bright = -1, bg_bright = -1;
-  char inverse = -1;
-
-  if (argc == 0) {
-    /* Reset mode */
-    fg_color = uv_tty_default_fg_color;
-    bg_color = uv_tty_default_bg_color;
-    fg_bright = uv_tty_default_fg_bright;
-    bg_bright = uv_tty_default_bg_bright;
-    inverse = uv_tty_default_inverse;
-  }
-
-  for (i = 0; i < argc; i++) {
-    short arg = argv[i];
-
-    if (arg == 0) {
-      /* Reset mode */
-      fg_color = uv_tty_default_fg_color;
-      bg_color = uv_tty_default_bg_color;
-      fg_bright = uv_tty_default_fg_bright;
-      bg_bright = uv_tty_default_bg_bright;
-      inverse = uv_tty_default_inverse;
-
-    } else if (arg == 1) {
-      /* Foreground bright on */
-      fg_bright = 1;
-
-    } else if (arg == 2) {
-      /* Both bright off */
-      fg_bright = 0;
-      bg_bright = 0;
-
-    } else if (arg == 5) {
-      /* Background bright on */
-      bg_bright = 1;
-
-    } else if (arg == 7) {
-      /* Inverse: on */
-      inverse = 1;
-
-    } else if (arg == 21 || arg == 22) {
-      /* Foreground bright off */
-      fg_bright = 0;
-
-    } else if (arg == 25) {
-      /* Background bright off */
-      bg_bright = 0;
-
-    } else if (arg == 27) {
-      /* Inverse: off */
-      inverse = 0;
-
-    } else if (arg >= 30 && arg <= 37) {
-      /* Set foreground color */
-      fg_color = arg - 30;
-
-    } else if (arg == 39) {
-      /* Default text color */
-      fg_color = uv_tty_default_fg_color;
-      fg_bright = uv_tty_default_fg_bright;
-
-    } else if (arg >= 40 && arg <= 47) {
-      /* Set background color */
-      bg_color = arg - 40;
-
-    } else if (arg ==  49) {
-      /* Default background color */
-      bg_color = uv_tty_default_bg_color;
-      bg_bright = uv_tty_default_bg_bright;
-
-    } else if (arg >= 90 && arg <= 97) {
-      /* Set bold foreground color */
-      fg_bright = 1;
-      fg_color = arg - 90;
-
-    } else if (arg >= 100 && arg <= 107) {
-      /* Set bold background color */
-      bg_bright = 1;
-      bg_color = arg - 100;
-
-    }
-  }
-
-  if (fg_color == -1 && bg_color == -1 && fg_bright == -1 &&
-      bg_bright == -1 && inverse == -1) {
-    /* Nothing changed */
-    return 0;
-  }
-
-  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
-    FLIP_FGBG;
-  }
-
-  if (fg_color != -1) {
-    info.wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
-    if (fg_color & 1) info.wAttributes |= FOREGROUND_RED;
-    if (fg_color & 2) info.wAttributes |= FOREGROUND_GREEN;
-    if (fg_color & 4) info.wAttributes |= FOREGROUND_BLUE;
-  }
-
-  if (fg_bright != -1) {
-    if (fg_bright) {
-      info.wAttributes |= FOREGROUND_INTENSITY;
-    } else {
-      info.wAttributes &= ~FOREGROUND_INTENSITY;
-    }
-  }
-
-  if (bg_color != -1) {
-    info.wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
-    if (bg_color & 1) info.wAttributes |= BACKGROUND_RED;
-    if (bg_color & 2) info.wAttributes |= BACKGROUND_GREEN;
-    if (bg_color & 4) info.wAttributes |= BACKGROUND_BLUE;
-  }
-
-  if (bg_bright != -1) {
-    if (bg_bright) {
-      info.wAttributes |= BACKGROUND_INTENSITY;
-    } else {
-      info.wAttributes &= ~BACKGROUND_INTENSITY;
-    }
-  }
-
-  if (inverse != -1) {
-    if (inverse) {
-      info.wAttributes |= COMMON_LVB_REVERSE_VIDEO;
-    } else {
-      info.wAttributes &= ~COMMON_LVB_REVERSE_VIDEO;
-    }
-  }
-
-  if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
-    FLIP_FGBG;
-  }
-
-  if (!SetConsoleTextAttribute(handle->handle, info.wAttributes)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  return 0;
-}
-
-
-static int uv_tty_save_state(uv_tty_t* handle, unsigned char save_attributes,
-    DWORD* error) {
-  CONSOLE_SCREEN_BUFFER_INFO info;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
-  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  uv_tty_update_virtual_window(&info);
-
-  handle->tty.wr.saved_position.X = info.dwCursorPosition.X;
-  handle->tty.wr.saved_position.Y = info.dwCursorPosition.Y - uv_tty_virtual_offset;
-  handle->flags |= UV_HANDLE_TTY_SAVED_POSITION;
-
-  if (save_attributes) {
-    handle->tty.wr.saved_attributes = info.wAttributes &
-        (FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
-    handle->flags |= UV_HANDLE_TTY_SAVED_ATTRIBUTES;
-  }
-
-  return 0;
-}
-
-
-static int uv_tty_restore_state(uv_tty_t* handle,
-    unsigned char restore_attributes, DWORD* error) {
-  CONSOLE_SCREEN_BUFFER_INFO info;
-  WORD new_attributes;
-
-  if (*error != ERROR_SUCCESS) {
-    return -1;
-  }
-
-  if (handle->flags & UV_HANDLE_TTY_SAVED_POSITION) {
-    if (uv_tty_move_caret(handle,
-                          handle->tty.wr.saved_position.X,
-                          0,
-                          handle->tty.wr.saved_position.Y,
-                          0,
-                          error) != 0) {
-      return -1;
-    }
-  }
-
-  if (restore_attributes &&
-      (handle->flags & UV_HANDLE_TTY_SAVED_ATTRIBUTES)) {
-    if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
-      *error = GetLastError();
-      return -1;
-    }
-
-    new_attributes = info.wAttributes;
-    new_attributes &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
-    new_attributes |= handle->tty.wr.saved_attributes;
-
-    if (!SetConsoleTextAttribute(handle->handle, new_attributes)) {
-      *error = GetLastError();
-      return -1;
-    }
-  }
-
-  return 0;
-}
-
-static int uv_tty_set_cursor_visibility(uv_tty_t* handle,
-                                        BOOL visible,
-                                        DWORD* error) {
-  CONSOLE_CURSOR_INFO cursor_info;
-
-  if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  cursor_info.bVisible = visible;
-
-  if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) {
-    *error = GetLastError();
-    return -1;
-  }
-
-  return 0;
-}
-
-static int uv_tty_write_bufs(uv_tty_t* handle,
-                             const uv_buf_t bufs[],
-                             unsigned int nbufs,
-                             DWORD* error) {
-  /* We can only write 8k characters at a time. Windows can't handle much more
-   * characters in a single console write anyway. */
-  WCHAR utf16_buf[MAX_CONSOLE_CHAR];
-  WCHAR* utf16_buffer;
-  DWORD utf16_buf_used = 0;
-  unsigned int i, len, max_len, pos;
-  int allocate = 0;
-
-#define FLUSH_TEXT()                                                 \
-  do {                                                               \
-    pos = 0;                                                         \
-    do {                                                             \
-      len = utf16_buf_used - pos;                                    \
-      if (len > MAX_CONSOLE_CHAR)                                    \
-        len = MAX_CONSOLE_CHAR;                                      \
-      uv_tty_emit_text(handle, &utf16_buffer[pos], len, error);      \
-      pos += len;                                                    \
-    } while (pos < utf16_buf_used);                                  \
-    if (allocate) {                                                  \
-      uv__free(utf16_buffer);                                        \
-      allocate = 0;                                                  \
-      utf16_buffer = utf16_buf;                                      \
-    }                                                                \
-    utf16_buf_used = 0;                                              \
- } while (0)
-
-#define ENSURE_BUFFER_SPACE(wchars_needed)                          \
-  if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {     \
-    FLUSH_TEXT();                                                   \
-  }
-
-  /* Cache for fast access */
-  unsigned char utf8_bytes_left = handle->tty.wr.utf8_bytes_left;
-  unsigned int utf8_codepoint = handle->tty.wr.utf8_codepoint;
-  unsigned char previous_eol = handle->tty.wr.previous_eol;
-  unsigned char ansi_parser_state = handle->tty.wr.ansi_parser_state;
-
-  /* Store the error here. If we encounter an error, stop trying to do i/o but
-   * keep parsing the buffer so we leave the parser in a consistent state. */
-  *error = ERROR_SUCCESS;
-
-  utf16_buffer = utf16_buf;
-
-  uv_sem_wait(&uv_tty_output_lock);
-
-  for (i = 0; i < nbufs; i++) {
-    uv_buf_t buf = bufs[i];
-    unsigned int j;
-
-    if (uv__vterm_state == UV_SUPPORTED && buf.len > 0) {
-      utf16_buf_used = MultiByteToWideChar(CP_UTF8,
-                                           0,
-                                           buf.base,
-                                           buf.len,
-                                           NULL,
-                                           0);
-
-      if (utf16_buf_used == 0) {
-        *error = GetLastError();
-        break;
-      }
-
-      max_len = (utf16_buf_used + 1) * sizeof(WCHAR);
-      allocate = max_len > MAX_CONSOLE_CHAR;
-      if (allocate)
-        utf16_buffer = (WCHAR*)uv__malloc(max_len);
-      if (!MultiByteToWideChar(CP_UTF8,
-                               0,
-                               buf.base,
-                               buf.len,
-                               utf16_buffer,
-                               utf16_buf_used)) {
-        if (allocate)
-          uv__free(utf16_buffer);
-        *error = GetLastError();
-        break;
-      }
-
-      FLUSH_TEXT();
-
-      continue;
-    }
-
-    for (j = 0; j < buf.len; j++) {
-      unsigned char c = buf.base[j];
-
-      /* Run the character through the utf8 decoder We happily accept non
-       * shortest form encodings and invalid code points - there's no real harm
-       * that can be done. */
-      if (utf8_bytes_left == 0) {
-        /* Read utf-8 start byte */
-        DWORD first_zero_bit;
-        unsigned char not_c = ~c;
-#ifdef _MSC_VER /* msvc */
-        if (_BitScanReverse(&first_zero_bit, not_c)) {
-#else /* assume gcc */
-        if (c != 0) {
-          first_zero_bit = (sizeof(int) * 8) - 1 - __builtin_clz(not_c);
-#endif
-          if (first_zero_bit == 7) {
-            /* Ascii - pass right through */
-            utf8_codepoint = (unsigned int) c;
-
-          } else if (first_zero_bit <= 5) {
-            /* Multibyte sequence */
-            utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c;
-            utf8_bytes_left = (char) (6 - first_zero_bit);
-
-          } else {
-            /* Invalid continuation */
-            utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
-          }
-
-        } else {
-          /* 0xff -- invalid */
-          utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
-        }
-
-      } else if ((c & 0xc0) == 0x80) {
-        /* Valid continuation of utf-8 multibyte sequence */
-        utf8_bytes_left--;
-        utf8_codepoint <<= 6;
-        utf8_codepoint |= ((unsigned int) c & 0x3f);
-
-      } else {
-        /* Start byte where continuation was expected. */
-        utf8_bytes_left = 0;
-        utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
-        /* Patch buf offset so this character will be parsed again as a start
-         * byte. */
-        j--;
-      }
-
-      /* Maybe we need to parse more bytes to find a character. */
-      if (utf8_bytes_left != 0) {
-        continue;
-      }
-
-      /* Parse vt100/ansi escape codes */
-      if (ansi_parser_state == ANSI_NORMAL) {
-        switch (utf8_codepoint) {
-          case '\033':
-            ansi_parser_state = ANSI_ESCAPE_SEEN;
-            continue;
-
-          case 0233:
-            ansi_parser_state = ANSI_CSI;
-            handle->tty.wr.ansi_csi_argc = 0;
-            continue;
-        }
-
-      } else if (ansi_parser_state == ANSI_ESCAPE_SEEN) {
-        switch (utf8_codepoint) {
-          case '[':
-            ansi_parser_state = ANSI_CSI;
-            handle->tty.wr.ansi_csi_argc = 0;
-            continue;
-
-          case '^':
-          case '_':
-          case 'P':
-          case ']':
-            /* Not supported, but we'll have to parse until we see a stop code,
-             * e. g. ESC \ or BEL. */
-            ansi_parser_state = ANSI_ST_CONTROL;
-            continue;
-
-          case '\033':
-            /* Ignore double escape. */
-            continue;
-
-          case 'c':
-            /* Full console reset. */
-            FLUSH_TEXT();
-            uv_tty_reset(handle, error);
-            ansi_parser_state = ANSI_NORMAL;
-            continue;
-
-          case '7':
-            /* Save the cursor position and text attributes. */
-            FLUSH_TEXT();
-            uv_tty_save_state(handle, 1, error);
-            ansi_parser_state = ANSI_NORMAL;
-            continue;
-
-           case '8':
-            /* Restore the cursor position and text attributes */
-            FLUSH_TEXT();
-            uv_tty_restore_state(handle, 1, error);
-            ansi_parser_state = ANSI_NORMAL;
-            continue;
-
-          default:
-            if (utf8_codepoint >= '@' && utf8_codepoint <= '_') {
-              /* Single-char control. */
-              ansi_parser_state = ANSI_NORMAL;
-              continue;
-            } else {
-              /* Invalid - proceed as normal, */
-              ansi_parser_state = ANSI_NORMAL;
-            }
-        }
-
-      } else if (ansi_parser_state & ANSI_CSI) {
-        if (!(ansi_parser_state & ANSI_IGNORE)) {
-          if (utf8_codepoint >= '0' && utf8_codepoint <= '9') {
-            /* Parsing a numerical argument */
-
-            if (!(ansi_parser_state & ANSI_IN_ARG)) {
-              /* We were not currently parsing a number */
-
-              /* Check for too many arguments */
-              if (handle->tty.wr.ansi_csi_argc >= ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
-                ansi_parser_state |= ANSI_IGNORE;
-                continue;
-              }
-
-              ansi_parser_state |= ANSI_IN_ARG;
-              handle->tty.wr.ansi_csi_argc++;
-              handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
-                  (unsigned short) utf8_codepoint - '0';
-              continue;
-            } else {
-              /* We were already parsing a number. Parse next digit. */
-              uint32_t value = 10 *
-                  handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1];
-
-              /* Check for overflow. */
-              if (value > UINT16_MAX) {
-                ansi_parser_state |= ANSI_IGNORE;
-                continue;
-              }
-
-               handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
-                   (unsigned short) value + (utf8_codepoint - '0');
-               continue;
-            }
-
-          } else if (utf8_codepoint == ';') {
-            /* Denotes the end of an argument. */
-            if (ansi_parser_state & ANSI_IN_ARG) {
-              ansi_parser_state &= ~ANSI_IN_ARG;
-              continue;
-
-            } else {
-              /* If ANSI_IN_ARG is not set, add another argument and default it
-               * to 0. */
-
-              /* Check for too many arguments */
-              if (handle->tty.wr.ansi_csi_argc >= ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
-                ansi_parser_state |= ANSI_IGNORE;
-                continue;
-              }
-
-              handle->tty.wr.ansi_csi_argc++;
-              handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 0;
-              continue;
-            }
-
-          } else if (utf8_codepoint == '?' && !(ansi_parser_state & ANSI_IN_ARG) &&
-                     handle->tty.wr.ansi_csi_argc == 0) {
-            /* Ignores '?' if it is the first character after CSI[. This is an
-             * extension character from the VT100 codeset that is supported and
-             * used by most ANSI terminals today. */
-            continue;
-
-          } else if (utf8_codepoint >= '@' && utf8_codepoint <= '~' &&
-                     (handle->tty.wr.ansi_csi_argc > 0 || utf8_codepoint != '[')) {
-            int x, y, d;
-
-            /* Command byte */
-            switch (utf8_codepoint) {
-              case 'A':
-                /* cursor up */
-                FLUSH_TEXT();
-                y = -(handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1);
-                uv_tty_move_caret(handle, 0, 1, y, 1, error);
-                break;
-
-              case 'B':
-                /* cursor down */
-                FLUSH_TEXT();
-                y = handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1;
-                uv_tty_move_caret(handle, 0, 1, y, 1, error);
-                break;
-
-              case 'C':
-                /* cursor forward */
-                FLUSH_TEXT();
-                x = handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1;
-                uv_tty_move_caret(handle, x, 1, 0, 1, error);
-                break;
-
-              case 'D':
-                /* cursor back */
-                FLUSH_TEXT();
-                x = -(handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1);
-                uv_tty_move_caret(handle, x, 1, 0, 1, error);
-                break;
-
-              case 'E':
-                /* cursor next line */
-                FLUSH_TEXT();
-                y = handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1;
-                uv_tty_move_caret(handle, 0, 0, y, 1, error);
-                break;
-
-              case 'F':
-                /* cursor previous line */
-                FLUSH_TEXT();
-                y = -(handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 1);
-                uv_tty_move_caret(handle, 0, 0, y, 1, error);
-                break;
-
-              case 'G':
-                /* cursor horizontal move absolute */
-                FLUSH_TEXT();
-                x = (handle->tty.wr.ansi_csi_argc >= 1 && handle->tty.wr.ansi_csi_argv[0])
-                  ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
-                uv_tty_move_caret(handle, x, 0, 0, 1, error);
-                break;
-
-              case 'H':
-              case 'f':
-                /* cursor move absolute */
-                FLUSH_TEXT();
-                y = (handle->tty.wr.ansi_csi_argc >= 1 && handle->tty.wr.ansi_csi_argv[0])
-                  ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
-                x = (handle->tty.wr.ansi_csi_argc >= 2 && handle->tty.wr.ansi_csi_argv[1])
-                  ? handle->tty.wr.ansi_csi_argv[1] - 1 : 0;
-                uv_tty_move_caret(handle, x, 0, y, 0, error);
-                break;
-
-              case 'J':
-                /* Erase screen */
-                FLUSH_TEXT();
-                d = handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 0;
-                if (d >= 0 && d <= 2) {
-                  uv_tty_clear(handle, d, 1, error);
-                }
-                break;
-
-              case 'K':
-                /* Erase line */
-                FLUSH_TEXT();
-                d = handle->tty.wr.ansi_csi_argc ? handle->tty.wr.ansi_csi_argv[0] : 0;
-                if (d >= 0 && d <= 2) {
-                  uv_tty_clear(handle, d, 0, error);
-                }
-                break;
-
-              case 'm':
-                /* Set style */
-                FLUSH_TEXT();
-                uv_tty_set_style(handle, error);
-                break;
-
-              case 's':
-                /* Save the cursor position. */
-                FLUSH_TEXT();
-                uv_tty_save_state(handle, 0, error);
-                break;
-
-              case 'u':
-                /* Restore the cursor position */
-                FLUSH_TEXT();
-                uv_tty_restore_state(handle, 0, error);
-                break;
-
-              case 'l':
-                /* Hide the cursor */
-                if (handle->tty.wr.ansi_csi_argc == 1 &&
-                    handle->tty.wr.ansi_csi_argv[0] == 25) {
-                  FLUSH_TEXT();
-                  uv_tty_set_cursor_visibility(handle, 0, error);
-                }
-                break;
-
-              case 'h':
-                /* Show the cursor */
-                if (handle->tty.wr.ansi_csi_argc == 1 &&
-                    handle->tty.wr.ansi_csi_argv[0] == 25) {
-                  FLUSH_TEXT();
-                  uv_tty_set_cursor_visibility(handle, 1, error);
-                }
-                break;
-            }
-
-            /* Sequence ended - go back to normal state. */
-            ansi_parser_state = ANSI_NORMAL;
-            continue;
-
-          } else {
-            /* We don't support commands that use private mode characters or
-             * intermediaries. Ignore the rest of the sequence. */
-            ansi_parser_state |= ANSI_IGNORE;
-            continue;
-          }
-        } else {
-          /* We're ignoring this command. Stop only on command character. */
-          if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
-            ansi_parser_state = ANSI_NORMAL;
-          }
-          continue;
-        }
-
-      } else if (ansi_parser_state & ANSI_ST_CONTROL) {
-        /* Unsupported control code.
-         * Ignore everything until we see `BEL` or `ESC \`. */
-        if (ansi_parser_state & ANSI_IN_STRING) {
-          if (!(ansi_parser_state & ANSI_BACKSLASH_SEEN)) {
-            if (utf8_codepoint == '"') {
-              ansi_parser_state &= ~ANSI_IN_STRING;
-            } else if (utf8_codepoint == '\\') {
-              ansi_parser_state |= ANSI_BACKSLASH_SEEN;
-            }
-          } else {
-            ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
-          }
-        } else {
-          if (utf8_codepoint == '\007' || (utf8_codepoint == '\\' &&
-              (ansi_parser_state & ANSI_ESCAPE_SEEN))) {
-            /* End of sequence */
-            ansi_parser_state = ANSI_NORMAL;
-          } else if (utf8_codepoint == '\033') {
-            /* Escape character */
-            ansi_parser_state |= ANSI_ESCAPE_SEEN;
-          } else if (utf8_codepoint == '"') {
-             /* String starting */
-            ansi_parser_state |= ANSI_IN_STRING;
-            ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
-            ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
-          } else {
-            ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
-          }
-        }
-        continue;
-      } else {
-        /* Inconsistent state */
-        abort();
-      }
-
-      /* We wouldn't mind emitting utf-16 surrogate pairs. Too bad, the windows
-       * console doesn't really support UTF-16, so just emit the replacement
-       * character. */
-      if (utf8_codepoint > 0xffff) {
-        utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
-      }
-
-      if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) {
-        /* EOL conversion - emit \r\n when we see \n. */
-
-        if (utf8_codepoint == 0x0a && previous_eol != 0x0d) {
-          /* \n was not preceded by \r; print \r\n. */
-          ENSURE_BUFFER_SPACE(2);
-          utf16_buf[utf16_buf_used++] = L'\r';
-          utf16_buf[utf16_buf_used++] = L'\n';
-        } else if (utf8_codepoint == 0x0d && previous_eol == 0x0a) {
-          /* \n was followed by \r; do not print the \r, since the source was
-           * either \r\n\r (so the second \r is redundant) or was \n\r (so the
-           * \n was processed by the last case and an \r automatically
-           * inserted). */
-        } else {
-          /* \r without \n; print \r as-is. */
-          ENSURE_BUFFER_SPACE(1);
-          utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
-        }
-
-        previous_eol = (char) utf8_codepoint;
-
-      } else if (utf8_codepoint <= 0xffff) {
-        /* Encode character into utf-16 buffer. */
-        ENSURE_BUFFER_SPACE(1);
-        utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
-        previous_eol = 0;
-      }
-    }
-  }
-
-  /* Flush remaining characters */
-  FLUSH_TEXT();
-
-  /* Copy cached values back to struct. */
-  handle->tty.wr.utf8_bytes_left = utf8_bytes_left;
-  handle->tty.wr.utf8_codepoint = utf8_codepoint;
-  handle->tty.wr.previous_eol = previous_eol;
-  handle->tty.wr.ansi_parser_state = ansi_parser_state;
-
-  uv_sem_post(&uv_tty_output_lock);
-
-  if (*error == STATUS_SUCCESS) {
-    return 0;
-  } else {
-    return -1;
-  }
-
-#undef FLUSH_TEXT
-}
-
-
-int uv_tty_write(uv_loop_t* loop,
-                 uv_write_t* req,
-                 uv_tty_t* handle,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs,
-                 uv_write_cb cb) {
-  DWORD error;
-
-  UV_REQ_INIT(req, UV_WRITE);
-  req->handle = (uv_stream_t*) handle;
-  req->cb = cb;
-
-  handle->reqs_pending++;
-  handle->stream.conn.write_reqs_pending++;
-  REGISTER_HANDLE_REQ(loop, handle, req);
-
-  req->u.io.queued_bytes = 0;
-
-  if (!uv_tty_write_bufs(handle, bufs, nbufs, &error)) {
-    SET_REQ_SUCCESS(req);
-  } else {
-    SET_REQ_ERROR(req, error);
-  }
-
-  uv_insert_pending_req(loop, (uv_req_t*) req);
-
-  return 0;
-}
-
-
-int uv__tty_try_write(uv_tty_t* handle,
-                      const uv_buf_t bufs[],
-                      unsigned int nbufs) {
-  DWORD error;
-
-  if (handle->stream.conn.write_reqs_pending > 0)
-    return UV_EAGAIN;
-
-  if (uv_tty_write_bufs(handle, bufs, nbufs, &error))
-    return uv_translate_sys_error(error);
-
-  return uv__count_bufs(bufs, nbufs);
-}
-
-
-void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
-  uv_write_t* req) {
-  int err;
-
-  handle->write_queue_size -= req->u.io.queued_bytes;
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (req->cb) {
-    err = GET_REQ_ERROR(req);
-    req->cb(req, uv_translate_sys_error(err));
-  }
-
-  handle->stream.conn.write_reqs_pending--;
-  if (handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-    uv_want_endgame(loop, (uv_handle_t*)handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_tty_close(uv_tty_t* handle) {
-  assert(handle->u.fd == -1 || handle->u.fd > 2);
-  if (handle->flags & UV_HANDLE_READING)
-    uv_tty_read_stop(handle);
-
-  if (handle->u.fd == -1)
-    CloseHandle(handle->handle);
-  else
-    close(handle->u.fd);
-
-  handle->u.fd = -1;
-  handle->handle = INVALID_HANDLE_VALUE;
-  handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
-  uv__handle_closing(handle);
-
-  if (handle->reqs_pending == 0) {
-    uv_want_endgame(handle->loop, (uv_handle_t*) handle);
-  }
-}
-
-
-void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
-  if (!(handle->flags & UV_HANDLE_TTY_READABLE) &&
-      handle->stream.conn.shutdown_req != NULL &&
-      handle->stream.conn.write_reqs_pending == 0) {
-    UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
-
-    /* TTY shutdown is really just a no-op */
-    if (handle->stream.conn.shutdown_req->cb) {
-      if (handle->flags & UV_HANDLE_CLOSING) {
-        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED);
-      } else {
-        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0);
-      }
-    }
-
-    handle->stream.conn.shutdown_req = NULL;
-
-    DECREASE_PENDING_REQ_COUNT(handle);
-    return;
-  }
-
-  if (handle->flags & UV_HANDLE_CLOSING &&
-      handle->reqs_pending == 0) {
-    /* The wait handle used for raw reading should be unregistered when the
-     * wait callback runs. */
-    assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
-           handle->tty.rd.read_raw_wait == NULL);
-
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-    uv__handle_close(handle);
-  }
-}
-
-
-/*
- * uv_process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working
- * TODO: find a way to remove it
- */
-void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_req_t* raw_req) {
-  abort();
-}
-
-
-/*
- * uv_process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working
- * TODO: find a way to remove it
- */
-void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
-    uv_connect_t* req) {
-  abort();
-}
-
-
-int uv_tty_reset_mode(void) {
-  /* Not necessary to do anything. */
-  return 0;
-}
-
-/* Determine whether or not this version of windows supports
- * proper ANSI color codes. Should be supported as of windows
- * 10 version 1511, build number 10.0.10586.
- */
-static void uv__determine_vterm_state(HANDLE handle) {
-  DWORD dwMode = 0;
-
-  if (!GetConsoleMode(handle, &dwMode)) {
-    uv__vterm_state = UV_UNSUPPORTED;
-    return;
-  }
-
-  dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-  if (!SetConsoleMode(handle, dwMode)) {
-    uv__vterm_state = UV_UNSUPPORTED;
-    return;
-  }
-
-  uv__vterm_state = UV_SUPPORTED;
-}
-
-static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param) {
-  CONSOLE_SCREEN_BUFFER_INFO sb_info;
-  MSG msg;
-
-  if (!GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info))
-    return 0;
-
-  uv__tty_console_width = sb_info.dwSize.X;
-  uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
-
-  if (pSetWinEventHook == NULL)
-    return 0;
-
-  if (!pSetWinEventHook(EVENT_CONSOLE_LAYOUT,
-                        EVENT_CONSOLE_LAYOUT,
-                        NULL,
-                        uv__tty_console_resize_event,
-                        0,
-                        0,
-                        WINEVENT_OUTOFCONTEXT))
-    return 0;
-
-  while (GetMessage(&msg, NULL, 0, 0)) {
-    TranslateMessage(&msg);
-    DispatchMessage(&msg);
-  }
-  return 0;
-}
-
-static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook,
-                                                  DWORD event,
-                                                  HWND hwnd,
-                                                  LONG idObject,
-                                                  LONG idChild,
-                                                  DWORD dwEventThread,
-                                                  DWORD dwmsEventTime) {
-  CONSOLE_SCREEN_BUFFER_INFO sb_info;
-  int width, height;
-
-  if (!GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info))
-    return;
-
-  width = sb_info.dwSize.X;
-  height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
-
-  if (width != uv__tty_console_width || height != uv__tty_console_height) {
-    uv__tty_console_width = width;
-    uv__tty_console_height = height;
-    uv__signal_dispatch(SIGWINCH);
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/udp.cpp b/wpiutil/src/main/native/libuv/src/win/udp.cpp
deleted file mode 100644
index 8aeeab3..0000000
--- a/wpiutil/src/main/native/libuv/src/win/udp.cpp
+++ /dev/null
@@ -1,1035 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "handle-inl.h"
-#include "stream-inl.h"
-#include "req-inl.h"
-
-
-/*
- * Threshold of active udp streams for which to preallocate udp read buffers.
- */
-const unsigned int uv_active_udp_streams_threshold = 0;
-
-/* A zero-size buffer for use by uv_udp_read */
-static char uv_zero_[] = "";
-int uv_udp_getpeername(const uv_udp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getpeername,
-                             name,
-                             namelen,
-                             0);
-}
-
-
-int uv_udp_getsockname(const uv_udp_t* handle,
-                       struct sockaddr* name,
-                       int* namelen) {
-
-  return uv__getsockpeername((const uv_handle_t*) handle,
-                             getsockname,
-                             name,
-                             namelen,
-                             0);
-}
-
-
-static int uv_udp_set_socket(uv_loop_t* loop, uv_udp_t* handle, SOCKET socket,
-    int family) {
-  DWORD yes = 1;
-  WSAPROTOCOL_INFOW info;
-  int opt_len;
-
-  if (handle->socket != INVALID_SOCKET)
-    return UV_EBUSY;
-
-  /* Set the socket to nonblocking mode */
-  if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
-    return WSAGetLastError();
-  }
-
-  /* Make the socket non-inheritable */
-  if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
-    return GetLastError();
-  }
-
-  /* Associate it with the I/O completion port. Use uv_handle_t pointer as
-   * completion key. */
-  if (CreateIoCompletionPort((HANDLE)socket,
-                             loop->iocp,
-                             (ULONG_PTR)socket,
-                             0) == NULL) {
-    return GetLastError();
-  }
-
-  /* All known Windows that support SetFileCompletionNotificationModes have a
-   * bug that makes it impossible to use this function in conjunction with
-   * datagram sockets. We can work around that but only if the user is using
-   * the default UDP driver (AFD) and has no other. LSPs stacked on top. Here
-   * we check whether that is the case. */
-  opt_len = (int) sizeof info;
-  if (getsockopt(
-          socket, SOL_SOCKET, SO_PROTOCOL_INFOW, (char*) &info, &opt_len) ==
-      SOCKET_ERROR) {
-    return GetLastError();
-  }
-
-  if (info.ProtocolChain.ChainLen == 1) {
-    if (SetFileCompletionNotificationModes(
-            (HANDLE) socket,
-            FILE_SKIP_SET_EVENT_ON_HANDLE |
-                FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
-      handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
-      handle->func_wsarecv = uv_wsarecv_workaround;
-      handle->func_wsarecvfrom = uv_wsarecvfrom_workaround;
-    } else if (GetLastError() != ERROR_INVALID_FUNCTION) {
-      return GetLastError();
-    }
-  }
-
-  handle->socket = socket;
-
-  if (family == AF_INET6) {
-    handle->flags |= UV_HANDLE_IPV6;
-  } else {
-    assert(!(handle->flags & UV_HANDLE_IPV6));
-  }
-
-  return 0;
-}
-
-
-int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags) {
-  int domain;
-
-  /* Use the lower 8 bits for the domain */
-  domain = flags & 0xFF;
-  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
-    return UV_EINVAL;
-
-  if (flags & ~0xFF)
-    return UV_EINVAL;
-
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_UDP);
-  handle->socket = INVALID_SOCKET;
-  handle->reqs_pending = 0;
-  handle->activecnt = 0;
-  handle->func_wsarecv = WSARecv;
-  handle->func_wsarecvfrom = WSARecvFrom;
-  handle->send_queue_size = 0;
-  handle->send_queue_count = 0;
-  UV_REQ_INIT(&handle->recv_req, UV_UDP_RECV);
-  handle->recv_req.data = handle;
-
-  /* If anything fails beyond this point we need to remove the handle from
-   * the handle queue, since it was added by uv__handle_init.
-   */
-
-  if (domain != AF_UNSPEC) {
-    SOCKET sock;
-    DWORD err;
-
-    sock = socket(domain, SOCK_DGRAM, 0);
-    if (sock == INVALID_SOCKET) {
-      err = WSAGetLastError();
-      QUEUE_REMOVE(&handle->handle_queue);
-      return uv_translate_sys_error(err);
-    }
-
-    err = uv_udp_set_socket(handle->loop, handle, sock, domain);
-    if (err) {
-      closesocket(sock);
-      QUEUE_REMOVE(&handle->handle_queue);
-      return uv_translate_sys_error(err);
-    }
-  }
-
-  return 0;
-}
-
-
-int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle) {
-  return uv_udp_init_ex(loop, handle, AF_UNSPEC);
-}
-
-
-void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle) {
-  uv_udp_recv_stop(handle);
-  closesocket(handle->socket);
-  handle->socket = INVALID_SOCKET;
-
-  uv__handle_closing(handle);
-
-  if (handle->reqs_pending == 0) {
-    uv_want_endgame(loop, (uv_handle_t*) handle);
-  }
-}
-
-
-void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
-  if (handle->flags & UV_HANDLE_CLOSING &&
-      handle->reqs_pending == 0) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-    uv__handle_close(handle);
-  }
-}
-
-
-static int uv_udp_maybe_bind(uv_udp_t* handle,
-                             const struct sockaddr* addr,
-                             unsigned int addrlen,
-                             unsigned int flags) {
-  int r;
-  int err;
-  DWORD no = 0;
-
-  if (handle->flags & UV_HANDLE_BOUND)
-    return 0;
-
-  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) {
-    /* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */
-    return ERROR_INVALID_PARAMETER;
-  }
-
-  if (handle->socket == INVALID_SOCKET) {
-    SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0);
-    if (sock == INVALID_SOCKET) {
-      return WSAGetLastError();
-    }
-
-    err = uv_udp_set_socket(handle->loop, handle, sock, addr->sa_family);
-    if (err) {
-      closesocket(sock);
-      return err;
-    }
-  }
-
-  if (flags & UV_UDP_REUSEADDR) {
-    DWORD yes = 1;
-    /* Set SO_REUSEADDR on the socket. */
-    if (setsockopt(handle->socket,
-                   SOL_SOCKET,
-                   SO_REUSEADDR,
-                   (char*) &yes,
-                   sizeof yes) == SOCKET_ERROR) {
-      err = WSAGetLastError();
-      return err;
-    }
-  }
-
-  if (addr->sa_family == AF_INET6)
-    handle->flags |= UV_HANDLE_IPV6;
-
-  if (addr->sa_family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) {
-    /* On windows IPV6ONLY is on by default. If the user doesn't specify it
-     * libuv turns it off. */
-
-    /* TODO: how to handle errors? This may fail if there is no ipv4 stack
-     * available, or when run on XP/2003 which have no support for dualstack
-     * sockets. For now we're silently ignoring the error. */
-    setsockopt(handle->socket,
-               IPPROTO_IPV6,
-               IPV6_V6ONLY,
-               (char*) &no,
-               sizeof no);
-  }
-
-  r = bind(handle->socket, addr, addrlen);
-  if (r == SOCKET_ERROR) {
-    return WSAGetLastError();
-  }
-
-  handle->flags |= UV_HANDLE_BOUND;
-
-  return 0;
-}
-
-
-static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
-  uv_req_t* req;
-  uv_buf_t buf;
-  DWORD bytes, flags;
-  int result;
-
-  assert(handle->flags & UV_HANDLE_READING);
-  assert(!(handle->flags & UV_HANDLE_READ_PENDING));
-
-  req = &handle->recv_req;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  /*
-   * Preallocate a read buffer if the number of active streams is below
-   * the threshold.
-  */
-  if (loop->active_udp_streams < uv_active_udp_streams_threshold) {
-    handle->flags &= ~UV_HANDLE_ZERO_READ;
-
-    handle->recv_buffer = uv_buf_init(NULL, 0);
-    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->recv_buffer);
-    if (handle->recv_buffer.base == NULL || handle->recv_buffer.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0);
-      return;
-    }
-    assert(handle->recv_buffer.base != NULL);
-
-    buf = handle->recv_buffer;
-    memset(&handle->recv_from, 0, sizeof handle->recv_from);
-    handle->recv_from_len = sizeof handle->recv_from;
-    flags = 0;
-
-    result = handle->func_wsarecvfrom(handle->socket,
-                                      (WSABUF*) &buf,
-                                      1,
-                                      &bytes,
-                                      &flags,
-                                      (struct sockaddr*) &handle->recv_from,
-                                      &handle->recv_from_len,
-                                      &req->u.io.overlapped,
-                                      NULL);
-
-    if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
-      /* Process the req without IOCP. */
-      handle->flags |= UV_HANDLE_READ_PENDING;
-      req->u.io.overlapped.InternalHigh = bytes;
-      handle->reqs_pending++;
-      uv_insert_pending_req(loop, req);
-    } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
-      /* The req will be processed with IOCP. */
-      handle->flags |= UV_HANDLE_READ_PENDING;
-      handle->reqs_pending++;
-    } else {
-      /* Make this req pending reporting an error. */
-      SET_REQ_ERROR(req, WSAGetLastError());
-      uv_insert_pending_req(loop, req);
-      handle->reqs_pending++;
-    }
-
-  } else {
-    handle->flags |= UV_HANDLE_ZERO_READ;
-
-    buf.base = (char*) uv_zero_;
-    buf.len = 0;
-    flags = MSG_PEEK;
-
-    result = handle->func_wsarecv(handle->socket,
-                                  (WSABUF*) &buf,
-                                  1,
-                                  &bytes,
-                                  &flags,
-                                  &req->u.io.overlapped,
-                                  NULL);
-
-    if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
-      /* Process the req without IOCP. */
-      handle->flags |= UV_HANDLE_READ_PENDING;
-      req->u.io.overlapped.InternalHigh = bytes;
-      handle->reqs_pending++;
-      uv_insert_pending_req(loop, req);
-    } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
-      /* The req will be processed with IOCP. */
-      handle->flags |= UV_HANDLE_READ_PENDING;
-      handle->reqs_pending++;
-    } else {
-      /* Make this req pending reporting an error. */
-      SET_REQ_ERROR(req, WSAGetLastError());
-      uv_insert_pending_req(loop, req);
-      handle->reqs_pending++;
-    }
-  }
-}
-
-
-int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
-    uv_udp_recv_cb recv_cb) {
-  uv_loop_t* loop = handle->loop;
-  int err;
-
-  if (handle->flags & UV_HANDLE_READING) {
-    return UV_EALREADY;
-  }
-
-  err = uv_udp_maybe_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip4_any_,
-                          sizeof(uv_addr_ip4_any_),
-                          0);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  handle->flags |= UV_HANDLE_READING;
-  INCREASE_ACTIVE_COUNT(loop, handle);
-  loop->active_udp_streams++;
-
-  handle->recv_cb = recv_cb;
-  handle->alloc_cb = alloc_cb;
-
-  /* If reading was stopped and then started again, there could still be a recv
-   * request pending. */
-  if (!(handle->flags & UV_HANDLE_READ_PENDING))
-    uv_udp_queue_recv(loop, handle);
-
-  return 0;
-}
-
-
-int uv__udp_recv_stop(uv_udp_t* handle) {
-  if (handle->flags & UV_HANDLE_READING) {
-    handle->flags &= ~UV_HANDLE_READING;
-    handle->loop->active_udp_streams--;
-    DECREASE_ACTIVE_COUNT(loop, handle);
-  }
-
-  return 0;
-}
-
-
-static int uv__send(uv_udp_send_t* req,
-                    uv_udp_t* handle,
-                    const uv_buf_t bufs[],
-                    unsigned int nbufs,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen,
-                    uv_udp_send_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  DWORD result, bytes;
-
-  UV_REQ_INIT(req, UV_UDP_SEND);
-  req->handle = handle;
-  req->cb = cb;
-  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
-
-  result = WSASendTo(handle->socket,
-                     (WSABUF*)bufs,
-                     nbufs,
-                     &bytes,
-                     0,
-                     addr,
-                     addrlen,
-                     &req->u.io.overlapped,
-                     NULL);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
-    /* Request completed immediately. */
-    req->u.io.queued_bytes = 0;
-    handle->reqs_pending++;
-    handle->send_queue_size += req->u.io.queued_bytes;
-    handle->send_queue_count++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
-    /* Request queued by the kernel. */
-    req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
-    handle->reqs_pending++;
-    handle->send_queue_size += req->u.io.queued_bytes;
-    handle->send_queue_count++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-  } else {
-    /* Send failed due to an error. */
-    return WSAGetLastError();
-  }
-
-  return 0;
-}
-
-
-void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
-    uv_req_t* req) {
-  uv_buf_t buf;
-  int partial;
-
-  assert(handle->type == UV_UDP);
-
-  handle->flags &= ~UV_HANDLE_READ_PENDING;
-
-  if (!REQ_SUCCESS(req)) {
-    DWORD err = GET_REQ_SOCK_ERROR(req);
-    if (err == WSAEMSGSIZE) {
-      /* Not a real error, it just indicates that the received packet was
-       * bigger than the receive buffer. */
-    } else if (err == WSAECONNRESET || err == WSAENETRESET) {
-      /* A previous sendto operation failed; ignore this error. If zero-reading
-       * we need to call WSARecv/WSARecvFrom _without_ the. MSG_PEEK flag to
-       * clear out the error queue. For nonzero reads, immediately queue a new
-       * receive. */
-      if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
-        goto done;
-      }
-    } else {
-      /* A real error occurred. Report the error to the user only if we're
-       * currently reading. */
-      if (handle->flags & UV_HANDLE_READING) {
-        uv_udp_recv_stop(handle);
-        buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
-              uv_buf_init(NULL, 0) : handle->recv_buffer;
-        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
-      }
-      goto done;
-    }
-  }
-
-  if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
-    /* Successful read */
-    partial = !REQ_SUCCESS(req);
-    handle->recv_cb(handle,
-                    req->u.io.overlapped.InternalHigh,
-                    &handle->recv_buffer,
-                    (const struct sockaddr*) &handle->recv_from,
-                    partial ? UV_UDP_PARTIAL : 0);
-  } else if (handle->flags & UV_HANDLE_READING) {
-    DWORD bytes, err, flags;
-    struct sockaddr_storage from;
-    int from_len;
-
-    /* Do a nonblocking receive.
-     * TODO: try to read multiple datagrams at once. FIONREAD maybe? */
-    buf = uv_buf_init(NULL, 0);
-    handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
-    if (buf.base == NULL || buf.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
-      goto done;
-    }
-    assert(buf.base != NULL);
-
-    memset(&from, 0, sizeof from);
-    from_len = sizeof from;
-
-    flags = 0;
-
-    if (WSARecvFrom(handle->socket,
-                    (WSABUF*)&buf,
-                    1,
-                    &bytes,
-                    &flags,
-                    (struct sockaddr*) &from,
-                    &from_len,
-                    NULL,
-                    NULL) != SOCKET_ERROR) {
-
-      /* Message received */
-      handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
-    } else {
-      err = WSAGetLastError();
-      if (err == WSAEMSGSIZE) {
-        /* Message truncated */
-        handle->recv_cb(handle,
-                        bytes,
-                        &buf,
-                        (const struct sockaddr*) &from,
-                        UV_UDP_PARTIAL);
-      } else if (err == WSAEWOULDBLOCK) {
-        /* Kernel buffer empty */
-        handle->recv_cb(handle, 0, &buf, NULL, 0);
-      } else if (err == WSAECONNRESET || err == WSAENETRESET) {
-        /* WSAECONNRESET/WSANETRESET is ignored because this just indicates
-         * that a previous sendto operation failed.
-         */
-        handle->recv_cb(handle, 0, &buf, NULL, 0);
-      } else {
-        /* Any other error that we want to report back to the user. */
-        uv_udp_recv_stop(handle);
-        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
-      }
-    }
-  }
-
-done:
-  /* Post another read if still reading and not closing. */
-  if ((handle->flags & UV_HANDLE_READING) &&
-      !(handle->flags & UV_HANDLE_READ_PENDING)) {
-    uv_udp_queue_recv(loop, handle);
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-void uv_process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
-    uv_udp_send_t* req) {
-  int err;
-
-  assert(handle->type == UV_UDP);
-
-  assert(handle->send_queue_size >= req->u.io.queued_bytes);
-  assert(handle->send_queue_count >= 1);
-  handle->send_queue_size -= req->u.io.queued_bytes;
-  handle->send_queue_count--;
-
-  UNREGISTER_HANDLE_REQ(loop, handle, req);
-
-  if (req->cb) {
-    err = 0;
-    if (!REQ_SUCCESS(req)) {
-      err = GET_REQ_SOCK_ERROR(req);
-    }
-    req->cb(req, uv_translate_sys_error(err));
-  }
-
-  DECREASE_PENDING_REQ_COUNT(handle);
-}
-
-
-static int uv__udp_set_membership4(uv_udp_t* handle,
-                                   const struct sockaddr_in* multicast_addr,
-                                   const char* interface_addr,
-                                   uv_membership membership) {
-  int err;
-  int optname;
-  struct ip_mreq mreq;
-
-  if (handle->flags & UV_HANDLE_IPV6)
-    return UV_EINVAL;
-
-  /* If the socket is unbound, bind to inaddr_any. */
-  err = uv_udp_maybe_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip4_any_,
-                          sizeof(uv_addr_ip4_any_),
-                          UV_UDP_REUSEADDR);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  memset(&mreq, 0, sizeof mreq);
-
-  if (interface_addr) {
-    err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
-    if (err)
-      return err;
-  } else {
-    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
-  }
-
-  mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
-
-  switch (membership) {
-    case UV_JOIN_GROUP:
-      optname = IP_ADD_MEMBERSHIP;
-      break;
-    case UV_LEAVE_GROUP:
-      optname = IP_DROP_MEMBERSHIP;
-      break;
-    default:
-      return UV_EINVAL;
-  }
-
-  if (setsockopt(handle->socket,
-                 IPPROTO_IP,
-                 optname,
-                 (char*) &mreq,
-                 sizeof mreq) == SOCKET_ERROR) {
-    return uv_translate_sys_error(WSAGetLastError());
-  }
-
-  return 0;
-}
-
-
-int uv__udp_set_membership6(uv_udp_t* handle,
-                            const struct sockaddr_in6* multicast_addr,
-                            const char* interface_addr,
-                            uv_membership membership) {
-  int optname;
-  int err;
-  struct ipv6_mreq mreq;
-  struct sockaddr_in6 addr6;
-
-  if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
-    return UV_EINVAL;
-
-  err = uv_udp_maybe_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip6_any_,
-                          sizeof(uv_addr_ip6_any_),
-                          UV_UDP_REUSEADDR);
-
-  if (err)
-    return uv_translate_sys_error(err);
-
-  memset(&mreq, 0, sizeof(mreq));
-
-  if (interface_addr) {
-    if (uv_ip6_addr(interface_addr, 0, &addr6))
-      return UV_EINVAL;
-    mreq.ipv6mr_interface = addr6.sin6_scope_id;
-  } else {
-    mreq.ipv6mr_interface = 0;
-  }
-
-  mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;
-
-  switch (membership) {
-  case UV_JOIN_GROUP:
-    optname = IPV6_ADD_MEMBERSHIP;
-    break;
-  case UV_LEAVE_GROUP:
-    optname = IPV6_DROP_MEMBERSHIP;
-    break;
-  default:
-    return UV_EINVAL;
-  }
-
-  if (setsockopt(handle->socket,
-                 IPPROTO_IPV6,
-                 optname,
-                 (char*) &mreq,
-                 sizeof mreq) == SOCKET_ERROR) {
-    return uv_translate_sys_error(WSAGetLastError());
-  }
-
-  return 0;
-}
-
-
-int uv_udp_set_membership(uv_udp_t* handle,
-                          const char* multicast_addr,
-                          const char* interface_addr,
-                          uv_membership membership) {
-  struct sockaddr_in addr4;
-  struct sockaddr_in6 addr6;
-
-  if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0)
-    return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
-  else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0)
-    return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
-  else
-    return UV_EINVAL;
-}
-
-
-int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
-  struct sockaddr_storage addr_st;
-  struct sockaddr_in* addr4;
-  struct sockaddr_in6* addr6;
-
-  addr4 = (struct sockaddr_in*) &addr_st;
-  addr6 = (struct sockaddr_in6*) &addr_st;
-
-  if (!interface_addr) {
-    memset(&addr_st, 0, sizeof addr_st);
-    if (handle->flags & UV_HANDLE_IPV6) {
-      addr_st.ss_family = AF_INET6;
-      addr6->sin6_scope_id = 0;
-    } else {
-      addr_st.ss_family = AF_INET;
-      addr4->sin_addr.s_addr = htonl(INADDR_ANY);
-    }
-  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
-    /* nothing, address was parsed */
-  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
-    /* nothing, address was parsed */
-  } else {
-    return UV_EINVAL;
-  }
-
-  if (handle->socket == INVALID_SOCKET)
-    return UV_EBADF;
-
-  if (addr_st.ss_family == AF_INET) {
-    if (setsockopt(handle->socket,
-                   IPPROTO_IP,
-                   IP_MULTICAST_IF,
-                   (char*) &addr4->sin_addr,
-                   sizeof(addr4->sin_addr)) == SOCKET_ERROR) {
-      return uv_translate_sys_error(WSAGetLastError());
-    }
-  } else if (addr_st.ss_family == AF_INET6) {
-    if (setsockopt(handle->socket,
-                   IPPROTO_IPV6,
-                   IPV6_MULTICAST_IF,
-                   (char*) &addr6->sin6_scope_id,
-                   sizeof(addr6->sin6_scope_id)) == SOCKET_ERROR) {
-      return uv_translate_sys_error(WSAGetLastError());
-    }
-  } else {
-    assert(0 && "unexpected address family");
-    abort();
-  }
-
-  return 0;
-}
-
-
-int uv_udp_set_broadcast(uv_udp_t* handle, int value) {
-  BOOL optval = (BOOL) value;
-
-  if (handle->socket == INVALID_SOCKET)
-    return UV_EBADF;
-
-  if (setsockopt(handle->socket,
-                 SOL_SOCKET,
-                 SO_BROADCAST,
-                 (char*) &optval,
-                 sizeof optval)) {
-    return uv_translate_sys_error(WSAGetLastError());
-  }
-
-  return 0;
-}
-
-
-int uv__udp_is_bound(uv_udp_t* handle) {
-  struct sockaddr_storage addr;
-  int addrlen;
-
-  addrlen = sizeof(addr);
-  if (uv_udp_getsockname(handle, (struct sockaddr*) &addr, &addrlen) != 0)
-    return 0;
-
-  return addrlen > 0;
-}
-
-
-int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
-  WSAPROTOCOL_INFOW protocol_info;
-  int opt_len;
-  int err;
-
-  /* Detect the address family of the socket. */
-  opt_len = (int) sizeof protocol_info;
-  if (getsockopt(sock,
-                 SOL_SOCKET,
-                 SO_PROTOCOL_INFOW,
-                 (char*) &protocol_info,
-                 &opt_len) == SOCKET_ERROR) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  err = uv_udp_set_socket(handle->loop,
-                          handle,
-                          sock,
-                          protocol_info.iAddressFamily);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  if (uv__udp_is_bound(handle))
-    handle->flags |= UV_HANDLE_BOUND;
-
-  if (uv__udp_is_connected(handle))
-    handle->flags |= UV_HANDLE_UDP_CONNECTED;
-
-  return 0;
-}
-
-
-#define SOCKOPT_SETTER(name, option4, option6, validate)                      \
-  int uv_udp_set_##name(uv_udp_t* handle, int value) {                        \
-    DWORD optval = (DWORD) value;                                             \
-                                                                              \
-    if (!(validate(value))) {                                                 \
-      return UV_EINVAL;                                                       \
-    }                                                                         \
-                                                                              \
-    if (handle->socket == INVALID_SOCKET)                                     \
-      return UV_EBADF;                                                        \
-                                                                              \
-    if (!(handle->flags & UV_HANDLE_IPV6)) {                                  \
-      /* Set IPv4 socket option */                                            \
-      if (setsockopt(handle->socket,                                          \
-                     IPPROTO_IP,                                              \
-                     option4,                                                 \
-                     (char*) &optval,                                         \
-                     sizeof optval)) {                                        \
-        return uv_translate_sys_error(WSAGetLastError());                     \
-      }                                                                       \
-    } else {                                                                  \
-      /* Set IPv6 socket option */                                            \
-      if (setsockopt(handle->socket,                                          \
-                     IPPROTO_IPV6,                                            \
-                     option6,                                                 \
-                     (char*) &optval,                                         \
-                     sizeof optval)) {                                        \
-        return uv_translate_sys_error(WSAGetLastError());                     \
-      }                                                                       \
-    }                                                                         \
-    return 0;                                                                 \
-  }
-
-#define VALIDATE_TTL(value) ((value) >= 1 && (value) <= 255)
-#define VALIDATE_MULTICAST_TTL(value) ((value) >= -1 && (value) <= 255)
-#define VALIDATE_MULTICAST_LOOP(value) (1)
-
-SOCKOPT_SETTER(ttl,
-               IP_TTL,
-               IPV6_HOPLIMIT,
-               VALIDATE_TTL)
-SOCKOPT_SETTER(multicast_ttl,
-               IP_MULTICAST_TTL,
-               IPV6_MULTICAST_HOPS,
-               VALIDATE_MULTICAST_TTL)
-SOCKOPT_SETTER(multicast_loop,
-               IP_MULTICAST_LOOP,
-               IPV6_MULTICAST_LOOP,
-               VALIDATE_MULTICAST_LOOP)
-
-#undef SOCKOPT_SETTER
-#undef VALIDATE_TTL
-#undef VALIDATE_MULTICAST_TTL
-#undef VALIDATE_MULTICAST_LOOP
-
-
-/* This function is an egress point, i.e. it returns libuv errors rather than
- * system errors.
- */
-int uv__udp_bind(uv_udp_t* handle,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 unsigned int flags) {
-  int err;
-
-  err = uv_udp_maybe_bind(handle, addr, addrlen, flags);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  return 0;
-}
-
-
-int uv__udp_connect(uv_udp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen) {
-  const struct sockaddr* bind_addr;
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    if (addrlen == sizeof(uv_addr_ip4_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
-    else if (addrlen == sizeof(uv_addr_ip6_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
-    else
-      return UV_EINVAL;
-
-    err = uv_udp_maybe_bind(handle, bind_addr, addrlen, 0);
-    if (err)
-      return uv_translate_sys_error(err);
-  }
-
-  err = connect(handle->socket, addr, addrlen);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  handle->flags |= UV_HANDLE_UDP_CONNECTED;
-
-  return 0;
-}
-
-
-int uv__udp_disconnect(uv_udp_t* handle) {
-    int err;
-    struct sockaddr addr;
-
-    memset(&addr, 0, sizeof(addr));
-
-    err = connect(handle->socket, &addr, sizeof(addr));
-    if (err)
-      return uv_translate_sys_error(err);
-
-    handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
-    return 0;
-}
-
-
-/* This function is an egress point, i.e. it returns libuv errors rather than
- * system errors.
- */
-int uv__udp_send(uv_udp_send_t* req,
-                 uv_udp_t* handle,
-                 const uv_buf_t bufs[],
-                 unsigned int nbufs,
-                 const struct sockaddr* addr,
-                 unsigned int addrlen,
-                 uv_udp_send_cb send_cb) {
-  const struct sockaddr* bind_addr;
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    if (addrlen == sizeof(uv_addr_ip4_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
-    else if (addrlen == sizeof(uv_addr_ip6_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
-    else
-      return UV_EINVAL;
-
-    err = uv_udp_maybe_bind(handle, bind_addr, addrlen, 0);
-    if (err)
-      return uv_translate_sys_error(err);
-  }
-
-  err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
-  if (err)
-    return uv_translate_sys_error(err);
-
-  return 0;
-}
-
-
-int uv__udp_try_send(uv_udp_t* handle,
-                     const uv_buf_t bufs[],
-                     unsigned int nbufs,
-                     const struct sockaddr* addr,
-                     unsigned int addrlen) {
-  DWORD bytes;
-  const struct sockaddr* bind_addr;
-  struct sockaddr_storage converted;
-  int err;
-
-  assert(nbufs > 0);
-
-  if (addr != NULL) {
-    err = uv__convert_to_localhost_if_unspecified(addr, &converted);
-    if (err)
-      return err;
-  }
-
-  /* Already sending a message.*/
-  if (handle->send_queue_count != 0)
-    return UV_EAGAIN;
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    if (addrlen == sizeof(uv_addr_ip4_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
-    else if (addrlen == sizeof(uv_addr_ip6_any_))
-      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
-    else
-      return UV_EINVAL;
-    err = uv_udp_maybe_bind(handle, bind_addr, addrlen, 0);
-    if (err)
-      return uv_translate_sys_error(err);
-  }
-
-  err = WSASendTo(handle->socket,
-                  (WSABUF*)bufs,
-                  nbufs,
-                  &bytes,
-                  0,
-                  (const struct sockaddr*) &converted,
-                  addrlen,
-                  NULL,
-                  NULL);
-
-  if (err)
-    return uv_translate_sys_error(WSAGetLastError());
-
-  return bytes;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/util.cpp b/wpiutil/src/main/native/libuv/src/win/util.cpp
deleted file mode 100644
index b5afb1d..0000000
--- a/wpiutil/src/main/native/libuv/src/win/util.cpp
+++ /dev/null
@@ -1,1811 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <direct.h>
-#include <limits.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-#include <wchar.h>
-
-#include "uv.h"
-#include "internal.h"
-
-#include <winsock2.h>
-#include <winperf.h>
-#include <iphlpapi.h>
-#include <psapi.h>
-#include <tlhelp32.h>
-#include <windows.h>
-#include <userenv.h>
-#include <math.h>
-
-/*
- * Max title length; the only thing MSDN tells us about the maximum length
- * of the console title is that it is smaller than 64K. However in practice
- * it is much smaller, and there is no way to figure out what the exact length
- * of the title is or can be, at least not on XP. To make it even more
- * annoying, GetConsoleTitle fails when the buffer to be read into is bigger
- * than the actual maximum length. So we make a conservative guess here;
- * just don't put the novel you're writing in the title, unless the plot
- * survives truncation.
- */
-#define MAX_TITLE_LENGTH 8192
-
-/* The number of nanoseconds in one second. */
-#define UV__NANOSEC 1000000000
-
-/* Max user name length, from iphlpapi.h */
-#ifndef UNLEN
-# define UNLEN 256
-#endif
-
-
-/* Maximum environment variable size, including the terminating null */
-#define MAX_ENV_VAR_LENGTH 32767
-
-/* Cached copy of the process title, plus a mutex guarding it. */
-static char *process_title;
-static CRITICAL_SECTION process_title_lock;
-
-#pragma comment(lib, "Advapi32.lib")
-#pragma comment(lib, "IPHLPAPI.lib")
-#pragma comment(lib, "Psapi.lib")
-#pragma comment(lib, "Userenv.lib")
-#pragma comment(lib, "kernel32.lib")
-
-/* Interval (in seconds) of the high-resolution clock. */
-static double hrtime_interval_ = 0;
-
-
-/*
- * One-time initialization code for functionality defined in util.c.
- */
-void uv__util_init(void) {
-  LARGE_INTEGER perf_frequency;
-
-  /* Initialize process title access mutex. */
-  InitializeCriticalSection(&process_title_lock);
-
-  /* Retrieve high-resolution timer frequency
-   * and precompute its reciprocal.
-   */
-  if (QueryPerformanceFrequency(&perf_frequency)) {
-    hrtime_interval_ = 1.0 / perf_frequency.QuadPart;
-  } else {
-    hrtime_interval_= 0;
-  }
-}
-
-
-int uv_exepath(char* buffer, size_t* size_ptr) {
-  int utf8_len, utf16_buffer_len, utf16_len;
-  WCHAR* utf16_buffer;
-  int err;
-
-  if (buffer == NULL || size_ptr == NULL || *size_ptr == 0) {
-    return UV_EINVAL;
-  }
-
-  if (*size_ptr > 32768) {
-    /* Windows paths can never be longer than this. */
-    utf16_buffer_len = 32768;
-  } else {
-    utf16_buffer_len = (int) *size_ptr;
-  }
-
-  utf16_buffer = (WCHAR*) uv__malloc(sizeof(WCHAR) * utf16_buffer_len);
-  if (!utf16_buffer) {
-    return UV_ENOMEM;
-  }
-
-  /* Get the path as UTF-16. */
-  utf16_len = GetModuleFileNameW(NULL, utf16_buffer, utf16_buffer_len);
-  if (utf16_len <= 0) {
-    err = GetLastError();
-    goto error;
-  }
-
-  /* utf16_len contains the length, *not* including the terminating null. */
-  utf16_buffer[utf16_len] = L'\0';
-
-  /* Convert to UTF-8 */
-  utf8_len = WideCharToMultiByte(CP_UTF8,
-                                 0,
-                                 utf16_buffer,
-                                 -1,
-                                 buffer,
-                                 (int) *size_ptr,
-                                 NULL,
-                                 NULL);
-  if (utf8_len == 0) {
-    err = GetLastError();
-    goto error;
-  }
-
-  uv__free(utf16_buffer);
-
-  /* utf8_len *does* include the terminating null at this point, but the
-   * returned size shouldn't. */
-  *size_ptr = utf8_len - 1;
-  return 0;
-
- error:
-  uv__free(utf16_buffer);
-  return uv_translate_sys_error(err);
-}
-
-
-int uv_cwd(char* buffer, size_t* size) {
-  DWORD utf16_len;
-  WCHAR utf16_buffer[MAX_PATH];
-  int r;
-
-  if (buffer == NULL || size == NULL) {
-    return UV_EINVAL;
-  }
-
-  utf16_len = GetCurrentDirectoryW(MAX_PATH, utf16_buffer);
-  if (utf16_len == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (utf16_len > MAX_PATH) {
-    /* This should be impossible; however the CRT has a code path to deal with
-     * this scenario, so I added a check anyway. */
-    return UV_EIO;
-  }
-
-  /* utf16_len contains the length, *not* including the terminating null. */
-  utf16_buffer[utf16_len] = L'\0';
-
-  /* The returned directory should not have a trailing slash, unless it points
-   * at a drive root, like c:\. Remove it if needed. */
-  if (utf16_buffer[utf16_len - 1] == L'\\' &&
-      !(utf16_len == 3 && utf16_buffer[1] == L':')) {
-    utf16_len--;
-    utf16_buffer[utf16_len] = L'\0';
-  }
-
-  /* Check how much space we need */
-  r = WideCharToMultiByte(CP_UTF8,
-                          0,
-                          utf16_buffer,
-                          -1,
-                          NULL,
-                          0,
-                          NULL,
-                          NULL);
-  if (r == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (r > (int) *size) {
-    *size = r;
-    return UV_ENOBUFS;
-  }
-
-  /* Convert to UTF-8 */
-  r = WideCharToMultiByte(CP_UTF8,
-                          0,
-                          utf16_buffer,
-                          -1,
-                          buffer,
-                          *size > INT_MAX ? INT_MAX : (int) *size,
-                          NULL,
-                          NULL);
-  if (r == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  *size = r - 1;
-  return 0;
-}
-
-
-int uv_chdir(const char* dir) {
-  WCHAR utf16_buffer[MAX_PATH];
-  size_t utf16_len;
-  WCHAR drive_letter, env_var[4];
-
-  if (dir == NULL) {
-    return UV_EINVAL;
-  }
-
-  if (MultiByteToWideChar(CP_UTF8,
-                          0,
-                          dir,
-                          -1,
-                          utf16_buffer,
-                          MAX_PATH) == 0) {
-    DWORD error = GetLastError();
-    /* The maximum length of the current working directory is 260 chars,
-     * including terminating null. If it doesn't fit, the path name must be too
-     * long. */
-    if (error == ERROR_INSUFFICIENT_BUFFER) {
-      return UV_ENAMETOOLONG;
-    } else {
-      return uv_translate_sys_error(error);
-    }
-  }
-
-  if (!SetCurrentDirectoryW(utf16_buffer)) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  /* Windows stores the drive-local path in an "hidden" environment variable,
-   * which has the form "=C:=C:\Windows". SetCurrentDirectory does not update
-   * this, so we'll have to do it. */
-  utf16_len = GetCurrentDirectoryW(MAX_PATH, utf16_buffer);
-  if (utf16_len == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (utf16_len > MAX_PATH) {
-    return UV_EIO;
-  }
-
-  /* The returned directory should not have a trailing slash, unless it points
-   * at a drive root, like c:\. Remove it if needed. */
-  if (utf16_buffer[utf16_len - 1] == L'\\' &&
-      !(utf16_len == 3 && utf16_buffer[1] == L':')) {
-    utf16_len--;
-    utf16_buffer[utf16_len] = L'\0';
-  }
-
-  if (utf16_len < 2 || utf16_buffer[1] != L':') {
-    /* Doesn't look like a drive letter could be there - probably an UNC path.
-     * TODO: Need to handle win32 namespaces like \\?\C:\ ? */
-    drive_letter = 0;
-  } else if (utf16_buffer[0] >= L'A' && utf16_buffer[0] <= L'Z') {
-    drive_letter = utf16_buffer[0];
-  } else if (utf16_buffer[0] >= L'a' && utf16_buffer[0] <= L'z') {
-    /* Convert to uppercase. */
-    drive_letter = utf16_buffer[0] - L'a' + L'A';
-  } else {
-    /* Not valid. */
-    drive_letter = 0;
-  }
-
-  if (drive_letter != 0) {
-    /* Construct the environment variable name and set it. */
-    env_var[0] = L'=';
-    env_var[1] = drive_letter;
-    env_var[2] = L':';
-    env_var[3] = L'\0';
-
-    if (!SetEnvironmentVariableW(env_var, utf16_buffer)) {
-      return uv_translate_sys_error(GetLastError());
-    }
-  }
-
-  return 0;
-}
-
-
-void uv_loadavg(double avg[3]) {
-  /* Can't be implemented */
-  avg[0] = avg[1] = avg[2] = 0;
-}
-
-
-uint64_t uv_get_free_memory(void) {
-  MEMORYSTATUSEX memory_status;
-  memory_status.dwLength = sizeof(memory_status);
-
-  if (!GlobalMemoryStatusEx(&memory_status)) {
-     return -1;
-  }
-
-  return (uint64_t)memory_status.ullAvailPhys;
-}
-
-
-uint64_t uv_get_total_memory(void) {
-  MEMORYSTATUSEX memory_status;
-  memory_status.dwLength = sizeof(memory_status);
-
-  if (!GlobalMemoryStatusEx(&memory_status)) {
-    return -1;
-  }
-
-  return (uint64_t)memory_status.ullTotalPhys;
-}
-
-
-uint64_t uv_get_constrained_memory(void) {
-  return 0;  /* Memory constraints are unknown. */
-}
-
-
-uv_pid_t uv_os_getpid(void) {
-  return GetCurrentProcessId();
-}
-
-
-uv_pid_t uv_os_getppid(void) {
-  int parent_pid = -1;
-  HANDLE handle;
-  PROCESSENTRY32 pe;
-  DWORD current_pid = GetCurrentProcessId();
-
-  pe.dwSize = sizeof(PROCESSENTRY32);
-  handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-
-  if (Process32First(handle, &pe)) {
-    do {
-      if (pe.th32ProcessID == current_pid) {
-        parent_pid = pe.th32ParentProcessID;
-        break;
-      }
-    } while( Process32Next(handle, &pe));
-  }
-
-  CloseHandle(handle);
-  return parent_pid;
-}
-
-
-char** uv_setup_args(int argc, char** argv) {
-  return argv;
-}
-
-
-int uv_set_process_title(const char* title) {
-  int err;
-  int length;
-  WCHAR* title_w = NULL;
-
-  uv__once_init();
-
-  /* Find out how big the buffer for the wide-char title must be */
-  length = MultiByteToWideChar(CP_UTF8, 0, title, -1, NULL, 0);
-  if (!length) {
-    err = GetLastError();
-    goto done;
-  }
-
-  /* Convert to wide-char string */
-  title_w = (WCHAR*)uv__malloc(sizeof(WCHAR) * length);
-  if (!title_w) {
-    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");
-  }
-
-  length = MultiByteToWideChar(CP_UTF8, 0, title, -1, title_w, length);
-  if (!length) {
-    err = GetLastError();
-    goto done;
-  }
-
-  /* If the title must be truncated insert a \0 terminator there */
-  if (length > MAX_TITLE_LENGTH) {
-    title_w[MAX_TITLE_LENGTH - 1] = L'\0';
-  }
-
-  if (!SetConsoleTitleW(title_w)) {
-    err = GetLastError();
-    goto done;
-  }
-
-  EnterCriticalSection(&process_title_lock);
-  uv__free(process_title);
-  process_title = uv__strdup(title);
-  LeaveCriticalSection(&process_title_lock);
-
-  err = 0;
-
-done:
-  uv__free(title_w);
-  return uv_translate_sys_error(err);
-}
-
-
-static int uv__get_process_title(void) {
-  WCHAR title_w[MAX_TITLE_LENGTH];
-
-  if (!GetConsoleTitleW(title_w, sizeof(title_w) / sizeof(WCHAR))) {
-    return -1;
-  }
-
-  if (uv__convert_utf16_to_utf8(title_w, -1, &process_title) != 0)
-    return -1;
-
-  return 0;
-}
-
-
-int uv_get_process_title(char* buffer, size_t size) {
-  size_t len;
-
-  if (buffer == NULL || size == 0)
-    return UV_EINVAL;
-
-  uv__once_init();
-
-  EnterCriticalSection(&process_title_lock);
-  /*
-   * If the process_title was never read before nor explicitly set,
-   * we must query it with getConsoleTitleW
-   */
-  if (!process_title && uv__get_process_title() == -1) {
-    LeaveCriticalSection(&process_title_lock);
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  assert(process_title);
-  len = strlen(process_title) + 1;
-
-  if (size < len) {
-    LeaveCriticalSection(&process_title_lock);
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, process_title, len);
-  LeaveCriticalSection(&process_title_lock);
-
-  return 0;
-}
-
-
-uint64_t uv_hrtime(void) {
-  uv__once_init();
-  return uv__hrtime(UV__NANOSEC);
-}
-
-uint64_t uv__hrtime(double scale) {
-  LARGE_INTEGER counter;
-
-  /* If the performance interval is zero, there's no support. */
-  if (hrtime_interval_ == 0) {
-    return 0;
-  }
-
-  if (!QueryPerformanceCounter(&counter)) {
-    return 0;
-  }
-
-  /* Because we have no guarantee about the order of magnitude of the
-   * performance counter interval, integer math could cause this computation
-   * to overflow. Therefore we resort to floating point math.
-   */
-  return (uint64_t) ((double) counter.QuadPart * hrtime_interval_ * scale);
-}
-
-
-int uv_resident_set_memory(size_t* rss) {
-  HANDLE current_process;
-  PROCESS_MEMORY_COUNTERS pmc;
-
-  current_process = GetCurrentProcess();
-
-  if (!GetProcessMemoryInfo(current_process, &pmc, sizeof(pmc))) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  *rss = pmc.WorkingSetSize;
-
-  return 0;
-}
-
-
-int uv_uptime(double* uptime) {
-  BYTE stack_buffer[4096];
-  BYTE* malloced_buffer = NULL;
-  BYTE* buffer = (BYTE*) stack_buffer;
-  size_t buffer_size = sizeof(stack_buffer);
-  DWORD data_size;
-
-  PERF_DATA_BLOCK* data_block;
-  PERF_OBJECT_TYPE* object_type;
-  PERF_COUNTER_DEFINITION* counter_definition;
-
-  DWORD i;
-
-  for (;;) {
-    LONG result;
-
-    data_size = (DWORD) buffer_size;
-    result = RegQueryValueExW(HKEY_PERFORMANCE_DATA,
-                              L"2",
-                              NULL,
-                              NULL,
-                              buffer,
-                              &data_size);
-    if (result == ERROR_SUCCESS) {
-      break;
-    } else if (result != ERROR_MORE_DATA) {
-      *uptime = 0;
-      return uv_translate_sys_error(result);
-    }
-
-    buffer_size *= 2;
-    /* Don't let the buffer grow infinitely. */
-    if (buffer_size > 1 << 20) {
-      goto internalError;
-    }
-
-    uv__free(malloced_buffer);
-
-    buffer = malloced_buffer = (BYTE*) uv__malloc(buffer_size);
-    if (malloced_buffer == NULL) {
-      *uptime = 0;
-      return UV_ENOMEM;
-    }
-  }
-
-  if (data_size < sizeof(*data_block))
-    goto internalError;
-
-  data_block = (PERF_DATA_BLOCK*) buffer;
-
-  if (wmemcmp(data_block->Signature, L"PERF", 4) != 0)
-    goto internalError;
-
-  if (data_size < data_block->HeaderLength + sizeof(*object_type))
-    goto internalError;
-
-  object_type = (PERF_OBJECT_TYPE*) (buffer + data_block->HeaderLength);
-
-  if (object_type->NumInstances != PERF_NO_INSTANCES)
-    goto internalError;
-
-  counter_definition = (PERF_COUNTER_DEFINITION*) (buffer +
-      data_block->HeaderLength + object_type->HeaderLength);
-  for (i = 0; i < object_type->NumCounters; i++) {
-    if ((BYTE*) counter_definition + sizeof(*counter_definition) >
-        buffer + data_size) {
-      break;
-    }
-
-    if (counter_definition->CounterNameTitleIndex == 674 &&
-        counter_definition->CounterSize == sizeof(uint64_t)) {
-      if (counter_definition->CounterOffset + sizeof(uint64_t) > data_size ||
-          !(counter_definition->CounterType & PERF_OBJECT_TIMER)) {
-        goto internalError;
-      } else {
-        BYTE* address = (BYTE*) object_type + object_type->DefinitionLength +
-                        counter_definition->CounterOffset;
-        uint64_t value = *((uint64_t*) address);
-        *uptime = floor((double) (object_type->PerfTime.QuadPart - value) /
-                        (double) object_type->PerfFreq.QuadPart);
-        uv__free(malloced_buffer);
-        return 0;
-      }
-    }
-
-    counter_definition = (PERF_COUNTER_DEFINITION*)
-        ((BYTE*) counter_definition + counter_definition->ByteLength);
-  }
-
-  /* If we get here, the uptime value was not found. */
-  uv__free(malloced_buffer);
-  *uptime = 0;
-  return UV_ENOSYS;
-
- internalError:
-  uv__free(malloced_buffer);
-  *uptime = 0;
-  return UV_EIO;
-}
-
-
-int uv_cpu_info(uv_cpu_info_t** cpu_infos_ptr, int* cpu_count_ptr) {
-  uv_cpu_info_t* cpu_infos;
-  SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* sppi;
-  DWORD sppi_size;
-  SYSTEM_INFO system_info;
-  DWORD cpu_count, i;
-  NTSTATUS status;
-  ULONG result_size;
-  int err;
-  uv_cpu_info_t* cpu_info;
-
-  cpu_infos = NULL;
-  cpu_count = 0;
-  sppi = NULL;
-
-  uv__once_init();
-
-  GetSystemInfo(&system_info);
-  cpu_count = system_info.dwNumberOfProcessors;
-
-  cpu_infos = (uv_cpu_info_t*)uv__calloc(cpu_count, sizeof *cpu_infos);
-  if (cpu_infos == NULL) {
-    err = ERROR_OUTOFMEMORY;
-    goto error;
-  }
-
-  sppi_size = cpu_count * sizeof(*sppi);
-  sppi = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*)uv__malloc(sppi_size);
-  if (sppi == NULL) {
-    err = ERROR_OUTOFMEMORY;
-    goto error;
-  }
-
-  status = pNtQuerySystemInformation(SystemProcessorPerformanceInformation,
-                                     sppi,
-                                     sppi_size,
-                                     &result_size);
-  if (!NT_SUCCESS(status)) {
-    err = pRtlNtStatusToDosError(status);
-    goto error;
-  }
-
-  assert(result_size == sppi_size);
-
-  for (i = 0; i < cpu_count; i++) {
-    WCHAR key_name[128];
-    HKEY processor_key;
-    DWORD cpu_speed;
-    DWORD cpu_speed_size = sizeof(cpu_speed);
-    WCHAR cpu_brand[256];
-    DWORD cpu_brand_size = sizeof(cpu_brand);
-    size_t len;
-
-    len = _snwprintf(key_name,
-                     ARRAY_SIZE(key_name),
-                     L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\%d",
-                     i);
-
-    assert(len > 0 && len < ARRAY_SIZE(key_name));
-
-    err = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
-                        key_name,
-                        0,
-                        KEY_QUERY_VALUE,
-                        &processor_key);
-    if (err != ERROR_SUCCESS) {
-      goto error;
-    }
-
-    err = RegQueryValueExW(processor_key,
-                           L"~MHz",
-                           NULL,
-                           NULL,
-                           (BYTE*)&cpu_speed,
-                           &cpu_speed_size);
-    if (err != ERROR_SUCCESS) {
-      RegCloseKey(processor_key);
-      goto error;
-    }
-
-    err = RegQueryValueExW(processor_key,
-                           L"ProcessorNameString",
-                           NULL,
-                           NULL,
-                           (BYTE*)&cpu_brand,
-                           &cpu_brand_size);
-    RegCloseKey(processor_key);
-    if (err != ERROR_SUCCESS)
-      goto error;
-
-    cpu_info = &cpu_infos[i];
-    cpu_info->speed = cpu_speed;
-    cpu_info->cpu_times.user = sppi[i].UserTime.QuadPart / 10000;
-    cpu_info->cpu_times.sys = (sppi[i].KernelTime.QuadPart -
-        sppi[i].IdleTime.QuadPart) / 10000;
-    cpu_info->cpu_times.idle = sppi[i].IdleTime.QuadPart / 10000;
-    cpu_info->cpu_times.irq = sppi[i].InterruptTime.QuadPart / 10000;
-    cpu_info->cpu_times.nice = 0;
-
-    uv__convert_utf16_to_utf8(cpu_brand,
-                              cpu_brand_size / sizeof(WCHAR),
-                              &(cpu_info->model));
-  }
-
-  uv__free(sppi);
-
-  *cpu_count_ptr = cpu_count;
-  *cpu_infos_ptr = cpu_infos;
-
-  return 0;
-
- error:
-  if (cpu_infos != NULL) {
-    /* This is safe because the cpu_infos array is zeroed on allocation. */
-    for (i = 0; i < cpu_count; i++)
-      uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-  uv__free(sppi);
-
-  return uv_translate_sys_error(err);
-}
-
-
-void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) {
-  int i;
-
-  for (i = 0; i < count; i++) {
-    uv__free(cpu_infos[i].model);
-  }
-
-  uv__free(cpu_infos);
-}
-
-
-static int is_windows_version_or_greater(DWORD os_major,
-                                         DWORD os_minor,
-                                         WORD service_pack_major,
-                                         WORD service_pack_minor) {
-  OSVERSIONINFOEX osvi;
-  DWORDLONG condition_mask = 0;
-  int op = VER_GREATER_EQUAL;
-
-  /* Initialize the OSVERSIONINFOEX structure. */
-  ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
-  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-  osvi.dwMajorVersion = os_major;
-  osvi.dwMinorVersion = os_minor;
-  osvi.wServicePackMajor = service_pack_major;
-  osvi.wServicePackMinor = service_pack_minor;
-
-  /* Initialize the condition mask. */
-  VER_SET_CONDITION(condition_mask, VER_MAJORVERSION, op);
-  VER_SET_CONDITION(condition_mask, VER_MINORVERSION, op);
-  VER_SET_CONDITION(condition_mask, VER_SERVICEPACKMAJOR, op);
-  VER_SET_CONDITION(condition_mask, VER_SERVICEPACKMINOR, op);
-
-  /* Perform the test. */
-  return (int) VerifyVersionInfo(
-    &osvi,
-    VER_MAJORVERSION | VER_MINORVERSION |
-    VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR,
-    condition_mask);
-}
-
-
-static int address_prefix_match(int family,
-                                struct sockaddr* address,
-                                struct sockaddr* prefix_address,
-                                int prefix_len) {
-  uint8_t* address_data;
-  uint8_t* prefix_address_data;
-  int i;
-
-  assert(address->sa_family == family);
-  assert(prefix_address->sa_family == family);
-
-  if (family == AF_INET6) {
-    address_data = (uint8_t*) &(((struct sockaddr_in6 *) address)->sin6_addr);
-    prefix_address_data =
-      (uint8_t*) &(((struct sockaddr_in6 *) prefix_address)->sin6_addr);
-  } else {
-    address_data = (uint8_t*) &(((struct sockaddr_in *) address)->sin_addr);
-    prefix_address_data =
-      (uint8_t*) &(((struct sockaddr_in *) prefix_address)->sin_addr);
-  }
-
-  for (i = 0; i < prefix_len >> 3; i++) {
-    if (address_data[i] != prefix_address_data[i])
-      return 0;
-  }
-
-  if (prefix_len % 8)
-    return prefix_address_data[i] ==
-      (address_data[i] & (0xff << (8 - prefix_len % 8)));
-
-  return 1;
-}
-
-
-int uv_interface_addresses(uv_interface_address_t** addresses_ptr,
-    int* count_ptr) {
-  IP_ADAPTER_ADDRESSES* win_address_buf;
-  ULONG win_address_buf_size;
-  IP_ADAPTER_ADDRESSES* adapter;
-
-  uv_interface_address_t* uv_address_buf;
-  char* name_buf;
-  size_t uv_address_buf_size;
-  uv_interface_address_t* uv_address;
-
-  int count;
-
-  int is_vista_or_greater;
-  ULONG flags;
-
-  *addresses_ptr = NULL;
-  *count_ptr = 0;
-
-  is_vista_or_greater = is_windows_version_or_greater(6, 0, 0, 0);
-  if (is_vista_or_greater) {
-    flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
-      GAA_FLAG_SKIP_DNS_SERVER;
-  } else {
-    /* We need at least XP SP1. */
-    if (!is_windows_version_or_greater(5, 1, 1, 0))
-      return UV_ENOTSUP;
-
-    flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
-      GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_PREFIX;
-  }
-
-
-  /* Fetch the size of the adapters reported by windows, and then get the list
-   * itself. */
-  win_address_buf_size = 0;
-  win_address_buf = NULL;
-
-  for (;;) {
-    ULONG r;
-
-    /* If win_address_buf is 0, then GetAdaptersAddresses will fail with.
-     * ERROR_BUFFER_OVERFLOW, and the required buffer size will be stored in
-     * win_address_buf_size. */
-    r = GetAdaptersAddresses(AF_UNSPEC,
-                             flags,
-                             NULL,
-                             win_address_buf,
-                             &win_address_buf_size);
-
-    if (r == ERROR_SUCCESS)
-      break;
-
-    uv__free(win_address_buf);
-
-    switch (r) {
-      case ERROR_BUFFER_OVERFLOW:
-        /* This happens when win_address_buf is NULL or too small to hold all
-         * adapters. */
-        win_address_buf =
-            (IP_ADAPTER_ADDRESSES*)uv__malloc(win_address_buf_size);
-        if (win_address_buf == NULL)
-          return UV_ENOMEM;
-
-        continue;
-
-      case ERROR_NO_DATA: {
-        /* No adapters were found. */
-        uv_address_buf = (uv_interface_address_t*)uv__malloc(1);
-        if (uv_address_buf == NULL)
-          return UV_ENOMEM;
-
-        *count_ptr = 0;
-        *addresses_ptr = uv_address_buf;
-
-        return 0;
-      }
-
-      case ERROR_ADDRESS_NOT_ASSOCIATED:
-        return UV_EAGAIN;
-
-      case ERROR_INVALID_PARAMETER:
-        /* MSDN says:
-         *   "This error is returned for any of the following conditions: the
-         *   SizePointer parameter is NULL, the Address parameter is not
-         *   AF_INET, AF_INET6, or AF_UNSPEC, or the address information for
-         *   the parameters requested is greater than ULONG_MAX."
-         * Since the first two conditions are not met, it must be that the
-         * adapter data is too big.
-         */
-        return UV_ENOBUFS;
-
-      default:
-        /* Other (unspecified) errors can happen, but we don't have any special
-         * meaning for them. */
-        assert(r != ERROR_SUCCESS);
-        return uv_translate_sys_error(r);
-    }
-  }
-
-  /* Count the number of enabled interfaces and compute how much space is
-   * needed to store their info. */
-  count = 0;
-  uv_address_buf_size = 0;
-
-  for (adapter = win_address_buf;
-       adapter != NULL;
-       adapter = adapter->Next) {
-    IP_ADAPTER_UNICAST_ADDRESS* unicast_address;
-    int name_size;
-
-    /* Interfaces that are not 'up' should not be reported. Also skip
-     * interfaces that have no associated unicast address, as to avoid
-     * allocating space for the name for this interface. */
-    if (adapter->OperStatus != IfOperStatusUp ||
-        adapter->FirstUnicastAddress == NULL)
-      continue;
-
-    /* Compute the size of the interface name. */
-    name_size = WideCharToMultiByte(CP_UTF8,
-                                    0,
-                                    adapter->FriendlyName,
-                                    -1,
-                                    NULL,
-                                    0,
-                                    NULL,
-                                    FALSE);
-    if (name_size <= 0) {
-      uv__free(win_address_buf);
-      return uv_translate_sys_error(GetLastError());
-    }
-    uv_address_buf_size += name_size;
-
-    /* Count the number of addresses associated with this interface, and
-     * compute the size. */
-    for (unicast_address = (IP_ADAPTER_UNICAST_ADDRESS*)
-                           adapter->FirstUnicastAddress;
-         unicast_address != NULL;
-         unicast_address = unicast_address->Next) {
-      count++;
-      uv_address_buf_size += sizeof(uv_interface_address_t);
-    }
-  }
-
-  /* Allocate space to store interface data plus adapter names. */
-  uv_address_buf = (uv_interface_address_t*)uv__malloc(uv_address_buf_size);
-  if (uv_address_buf == NULL) {
-    uv__free(win_address_buf);
-    return UV_ENOMEM;
-  }
-
-  /* Compute the start of the uv_interface_address_t array, and the place in
-   * the buffer where the interface names will be stored. */
-  uv_address = uv_address_buf;
-  name_buf = (char*) (uv_address_buf + count);
-
-  /* Fill out the output buffer. */
-  for (adapter = win_address_buf;
-       adapter != NULL;
-       adapter = adapter->Next) {
-    IP_ADAPTER_UNICAST_ADDRESS* unicast_address;
-    int name_size;
-    size_t max_name_size;
-
-    if (adapter->OperStatus != IfOperStatusUp ||
-        adapter->FirstUnicastAddress == NULL)
-      continue;
-
-    /* Convert the interface name to UTF8. */
-    max_name_size = (char*) uv_address_buf + uv_address_buf_size - name_buf;
-    if (max_name_size > (size_t) INT_MAX)
-      max_name_size = INT_MAX;
-    name_size = WideCharToMultiByte(CP_UTF8,
-                                    0,
-                                    adapter->FriendlyName,
-                                    -1,
-                                    name_buf,
-                                    (int) max_name_size,
-                                    NULL,
-                                    FALSE);
-    if (name_size <= 0) {
-      uv__free(win_address_buf);
-      uv__free(uv_address_buf);
-      return uv_translate_sys_error(GetLastError());
-    }
-
-    /* Add an uv_interface_address_t element for every unicast address. */
-    for (unicast_address = (IP_ADAPTER_UNICAST_ADDRESS*)
-                           adapter->FirstUnicastAddress;
-         unicast_address != NULL;
-         unicast_address = unicast_address->Next) {
-      struct sockaddr* sa;
-      ULONG prefix_len;
-
-      sa = unicast_address->Address.lpSockaddr;
-
-      /* XP has no OnLinkPrefixLength field. */
-      if (is_vista_or_greater) {
-        prefix_len =
-          ((IP_ADAPTER_UNICAST_ADDRESS_LH*) unicast_address)->OnLinkPrefixLength;
-      } else {
-        /* Prior to Windows Vista the FirstPrefix pointed to the list with
-         * single prefix for each IP address assigned to the adapter.
-         * Order of FirstPrefix does not match order of FirstUnicastAddress,
-         * so we need to find corresponding prefix.
-         */
-        IP_ADAPTER_PREFIX* prefix;
-        prefix_len = 0;
-
-        for (prefix = adapter->FirstPrefix; prefix; prefix = prefix->Next) {
-          /* We want the longest matching prefix. */
-          if (prefix->Address.lpSockaddr->sa_family != sa->sa_family ||
-              prefix->PrefixLength <= prefix_len)
-            continue;
-
-          if (address_prefix_match(sa->sa_family, sa,
-              prefix->Address.lpSockaddr, prefix->PrefixLength)) {
-            prefix_len = prefix->PrefixLength;
-          }
-        }
-
-        /* If there is no matching prefix information, return a single-host
-         * subnet mask (e.g. 255.255.255.255 for IPv4).
-         */
-        if (!prefix_len)
-          prefix_len = (sa->sa_family == AF_INET6) ? 128 : 32;
-      }
-
-      memset(uv_address, 0, sizeof *uv_address);
-
-      uv_address->name = name_buf;
-
-      if (adapter->PhysicalAddressLength == sizeof(uv_address->phys_addr)) {
-        memcpy(uv_address->phys_addr,
-               adapter->PhysicalAddress,
-               sizeof(uv_address->phys_addr));
-      }
-
-      uv_address->is_internal =
-          (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK);
-
-      if (sa->sa_family == AF_INET6) {
-        uv_address->address.address6 = *((struct sockaddr_in6 *) sa);
-
-        uv_address->netmask.netmask6.sin6_family = AF_INET6;
-        memset(uv_address->netmask.netmask6.sin6_addr.s6_addr, 0xff, prefix_len >> 3);
-        /* This check ensures that we don't write past the size of the data. */
-        if (prefix_len % 8) {
-          uv_address->netmask.netmask6.sin6_addr.s6_addr[prefix_len >> 3] =
-              0xff << (8 - prefix_len % 8);
-        }
-
-      } else {
-        uv_address->address.address4 = *((struct sockaddr_in *) sa);
-
-        uv_address->netmask.netmask4.sin_family = AF_INET;
-        uv_address->netmask.netmask4.sin_addr.s_addr = (prefix_len > 0) ?
-            htonl(0xffffffff << (32 - prefix_len)) : 0;
-      }
-
-      uv_address++;
-    }
-
-    name_buf += name_size;
-  }
-
-  uv__free(win_address_buf);
-
-  *addresses_ptr = uv_address_buf;
-  *count_ptr = count;
-
-  return 0;
-}
-
-
-void uv_free_interface_addresses(uv_interface_address_t* addresses,
-    int count) {
-  uv__free(addresses);
-}
-
-
-int uv_getrusage(uv_rusage_t *uv_rusage) {
-  FILETIME createTime, exitTime, kernelTime, userTime;
-  SYSTEMTIME kernelSystemTime, userSystemTime;
-  PROCESS_MEMORY_COUNTERS memCounters;
-  IO_COUNTERS ioCounters;
-  int ret;
-
-  ret = GetProcessTimes(GetCurrentProcess(), &createTime, &exitTime, &kernelTime, &userTime);
-  if (ret == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  ret = FileTimeToSystemTime(&kernelTime, &kernelSystemTime);
-  if (ret == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  ret = FileTimeToSystemTime(&userTime, &userSystemTime);
-  if (ret == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  ret = GetProcessMemoryInfo(GetCurrentProcess(),
-                             &memCounters,
-                             sizeof(memCounters));
-  if (ret == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  ret = GetProcessIoCounters(GetCurrentProcess(), &ioCounters);
-  if (ret == 0) {
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  memset(uv_rusage, 0, sizeof(*uv_rusage));
-
-  uv_rusage->ru_utime.tv_sec = userSystemTime.wHour * 3600 +
-                               userSystemTime.wMinute * 60 +
-                               userSystemTime.wSecond;
-  uv_rusage->ru_utime.tv_usec = userSystemTime.wMilliseconds * 1000;
-
-  uv_rusage->ru_stime.tv_sec = kernelSystemTime.wHour * 3600 +
-                               kernelSystemTime.wMinute * 60 +
-                               kernelSystemTime.wSecond;
-  uv_rusage->ru_stime.tv_usec = kernelSystemTime.wMilliseconds * 1000;
-
-  uv_rusage->ru_majflt = (uint64_t) memCounters.PageFaultCount;
-  uv_rusage->ru_maxrss = (uint64_t) memCounters.PeakWorkingSetSize / 1024;
-
-  uv_rusage->ru_oublock = (uint64_t) ioCounters.WriteOperationCount;
-  uv_rusage->ru_inblock = (uint64_t) ioCounters.ReadOperationCount;
-
-  return 0;
-}
-
-
-int uv_os_homedir(char* buffer, size_t* size) {
-  uv_passwd_t pwd;
-  size_t len;
-  int r;
-
-  /* Check if the USERPROFILE environment variable is set first. The task of
-     performing input validation on buffer and size is taken care of by
-     uv_os_getenv(). */
-  r = uv_os_getenv("USERPROFILE", buffer, size);
-
-  /* Don't return an error if USERPROFILE was not found. */
-  if (r != UV_ENOENT)
-    return r;
-
-  /* USERPROFILE is not set, so call uv__getpwuid_r() */
-  r = uv__getpwuid_r(&pwd);
-
-  if (r != 0) {
-    return r;
-  }
-
-  len = strlen(pwd.homedir);
-
-  if (len >= *size) {
-    *size = len + 1;
-    uv_os_free_passwd(&pwd);
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, pwd.homedir, len + 1);
-  *size = len;
-  uv_os_free_passwd(&pwd);
-
-  return 0;
-}
-
-
-int uv_os_tmpdir(char* buffer, size_t* size) {
-  wchar_t path[MAX_PATH + 1];
-  DWORD bufsize;
-  size_t len;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  len = GetTempPathW(MAX_PATH + 1, path);
-
-  if (len == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (len > MAX_PATH + 1) {
-    /* This should not be possible */
-    return UV_EIO;
-  }
-
-  /* The returned directory should not have a trailing slash, unless it points
-   * at a drive root, like c:\. Remove it if needed. */
-  if (path[len - 1] == L'\\' &&
-      !(len == 3 && path[1] == L':')) {
-    len--;
-    path[len] = L'\0';
-  }
-
-  /* Check how much space we need */
-  bufsize = WideCharToMultiByte(CP_UTF8, 0, path, -1, NULL, 0, NULL, NULL);
-
-  if (bufsize == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (bufsize > *size) {
-    *size = bufsize;
-    return UV_ENOBUFS;
-  }
-
-  /* Convert to UTF-8 */
-  bufsize = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                path,
-                                -1,
-                                buffer,
-                                *size,
-                                NULL,
-                                NULL);
-
-  if (bufsize == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  *size = bufsize - 1;
-  return 0;
-}
-
-
-void uv_os_free_passwd(uv_passwd_t* pwd) {
-  if (pwd == NULL)
-    return;
-
-  uv__free(pwd->username);
-  uv__free(pwd->homedir);
-  pwd->username = NULL;
-  pwd->homedir = NULL;
-}
-
-
-/*
- * Converts a UTF-16 string into a UTF-8 one. The resulting string is
- * null-terminated.
- *
- * If utf16 is null terminated, utf16len can be set to -1, otherwise it must
- * be specified.
- */
-int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8) {
-  DWORD bufsize;
-
-  if (utf16 == NULL)
-    return UV_EINVAL;
-
-  /* Check how much space we need */
-  bufsize = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                utf16,
-                                utf16len,
-                                NULL,
-                                0,
-                                NULL,
-                                NULL);
-
-  if (bufsize == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  /* Allocate the destination buffer adding an extra byte for the terminating
-   * NULL. If utf16len is not -1 WideCharToMultiByte will not add it, so
-   * we do it ourselves always, just in case. */
-  *utf8 = (char*)uv__malloc(bufsize + 1);
-
-  if (*utf8 == NULL)
-    return UV_ENOMEM;
-
-  /* Convert to UTF-8 */
-  bufsize = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                utf16,
-                                utf16len,
-                                *utf8,
-                                bufsize,
-                                NULL,
-                                NULL);
-
-  if (bufsize == 0) {
-    uv__free(*utf8);
-    *utf8 = NULL;
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  (*utf8)[bufsize] = '\0';
-  return 0;
-}
-
-
-/*
- * Converts a UTF-8 string into a UTF-16 one. The resulting string is
- * null-terminated.
- *
- * If utf8 is null terminated, utf8len can be set to -1, otherwise it must
- * be specified.
- */
-int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16) {
-  int bufsize;
-
-  if (utf8 == NULL)
-    return UV_EINVAL;
-
-  /* Check how much space we need */
-  bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, NULL, 0);
-
-  if (bufsize == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  /* Allocate the destination buffer adding an extra byte for the terminating
-   * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so
-   * we do it ourselves always, just in case. */
-  *utf16 = (WCHAR*)uv__malloc(sizeof(WCHAR) * (bufsize + 1));
-
-  if (*utf16 == NULL)
-    return UV_ENOMEM;
-
-  /* Convert to UTF-16 */
-  bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, *utf16, bufsize);
-
-  if (bufsize == 0) {
-    uv__free(*utf16);
-    *utf16 = NULL;
-    return uv_translate_sys_error(GetLastError());
-  }
-
-  (*utf16)[bufsize] = '\0';
-  return 0;
-}
-
-
-int uv__getpwuid_r(uv_passwd_t* pwd) {
-  HANDLE token;
-  wchar_t username[UNLEN + 1];
-  wchar_t path[MAX_PATH];
-  DWORD bufsize;
-  int r;
-
-  if (pwd == NULL)
-    return UV_EINVAL;
-
-  /* Get the home directory using GetUserProfileDirectoryW() */
-  if (OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token) == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  bufsize = ARRAY_SIZE(path);
-  if (!GetUserProfileDirectoryW(token, path, &bufsize)) {
-    r = GetLastError();
-    CloseHandle(token);
-
-    /* This should not be possible */
-    if (r == ERROR_INSUFFICIENT_BUFFER)
-      return UV_ENOMEM;
-
-    return uv_translate_sys_error(r);
-  }
-
-  CloseHandle(token);
-
-  /* Get the username using GetUserNameW() */
-  bufsize = ARRAY_SIZE(username);
-  if (!GetUserNameW(username, &bufsize)) {
-    r = GetLastError();
-
-    /* This should not be possible */
-    if (r == ERROR_INSUFFICIENT_BUFFER)
-      return UV_ENOMEM;
-
-    return uv_translate_sys_error(r);
-  }
-
-  pwd->homedir = NULL;
-  r = uv__convert_utf16_to_utf8(path, -1, &pwd->homedir);
-
-  if (r != 0)
-    return r;
-
-  pwd->username = NULL;
-  r = uv__convert_utf16_to_utf8(username, -1, &pwd->username);
-
-  if (r != 0) {
-    uv__free(pwd->homedir);
-    return r;
-  }
-
-  pwd->shell = NULL;
-  pwd->uid = -1;
-  pwd->gid = -1;
-
-  return 0;
-}
-
-
-int uv_os_get_passwd(uv_passwd_t* pwd) {
-  return uv__getpwuid_r(pwd);
-}
-
-
-int uv_os_getenv(const char* name, char* buffer, size_t* size) {
-  wchar_t var[MAX_ENV_VAR_LENGTH];
-  wchar_t* name_w;
-  DWORD bufsize;
-  size_t len;
-  int r;
-
-  if (name == NULL || buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  r = uv__convert_utf8_to_utf16(name, -1, &name_w);
-
-  if (r != 0)
-    return r;
-
-  len = GetEnvironmentVariableW(name_w, var, MAX_ENV_VAR_LENGTH);
-  uv__free(name_w);
-  assert(len < MAX_ENV_VAR_LENGTH); /* len does not include the null */
-
-  if (len == 0) {
-    r = GetLastError();
-
-    if (r == ERROR_ENVVAR_NOT_FOUND)
-      return UV_ENOENT;
-
-    return uv_translate_sys_error(r);
-  }
-
-  /* Check how much space we need */
-  bufsize = WideCharToMultiByte(CP_UTF8, 0, var, -1, NULL, 0, NULL, NULL);
-
-  if (bufsize == 0) {
-    return uv_translate_sys_error(GetLastError());
-  } else if (bufsize > *size) {
-    *size = bufsize;
-    return UV_ENOBUFS;
-  }
-
-  /* Convert to UTF-8 */
-  bufsize = WideCharToMultiByte(CP_UTF8,
-                                0,
-                                var,
-                                -1,
-                                buffer,
-                                *size,
-                                NULL,
-                                NULL);
-
-  if (bufsize == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  *size = bufsize - 1;
-  return 0;
-}
-
-
-int uv_os_setenv(const char* name, const char* value) {
-  wchar_t* name_w;
-  wchar_t* value_w;
-  int r;
-
-  if (name == NULL || value == NULL)
-    return UV_EINVAL;
-
-  r = uv__convert_utf8_to_utf16(name, -1, &name_w);
-
-  if (r != 0)
-    return r;
-
-  r = uv__convert_utf8_to_utf16(value, -1, &value_w);
-
-  if (r != 0) {
-    uv__free(name_w);
-    return r;
-  }
-
-  r = SetEnvironmentVariableW(name_w, value_w);
-  uv__free(name_w);
-  uv__free(value_w);
-
-  if (r == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  return 0;
-}
-
-
-int uv_os_unsetenv(const char* name) {
-  wchar_t* name_w;
-  int r;
-
-  if (name == NULL)
-    return UV_EINVAL;
-
-  r = uv__convert_utf8_to_utf16(name, -1, &name_w);
-
-  if (r != 0)
-    return r;
-
-  r = SetEnvironmentVariableW(name_w, NULL);
-  uv__free(name_w);
-
-  if (r == 0)
-    return uv_translate_sys_error(GetLastError());
-
-  return 0;
-}
-
-
-int uv_os_gethostname(char* buffer, size_t* size) {
-  char buf[UV_MAXHOSTNAMESIZE];
-  size_t len;
-
-  if (buffer == NULL || size == NULL || *size == 0)
-    return UV_EINVAL;
-
-  uv__once_init(); /* Initialize winsock */
-
-  if (gethostname(buf, sizeof(buf)) != 0)
-    return uv_translate_sys_error(WSAGetLastError());
-
-  buf[sizeof(buf) - 1] = '\0'; /* Null terminate, just to be safe. */
-  len = strlen(buf);
-
-  if (len >= *size) {
-    *size = len + 1;
-    return UV_ENOBUFS;
-  }
-
-  memcpy(buffer, buf, len + 1);
-  *size = len;
-  return 0;
-}
-
-
-static int uv__get_handle(uv_pid_t pid, int access, HANDLE* handle) {
-  int r;
-
-  if (pid == 0)
-    *handle = GetCurrentProcess();
-  else
-    *handle = OpenProcess(access, FALSE, pid);
-
-  if (*handle == NULL) {
-    r = GetLastError();
-
-    if (r == ERROR_INVALID_PARAMETER)
-      return UV_ESRCH;
-    else
-      return uv_translate_sys_error(r);
-  }
-
-  return 0;
-}
-
-
-int uv_os_getpriority(uv_pid_t pid, int* priority) {
-  HANDLE handle;
-  int r;
-
-  if (priority == NULL)
-    return UV_EINVAL;
-
-  r = uv__get_handle(pid, PROCESS_QUERY_LIMITED_INFORMATION, &handle);
-
-  if (r != 0)
-    return r;
-
-  r = GetPriorityClass(handle);
-
-  if (r == 0) {
-    r = uv_translate_sys_error(GetLastError());
-  } else {
-    /* Map Windows priority classes to Unix nice values. */
-    if (r == REALTIME_PRIORITY_CLASS)
-      *priority = UV_PRIORITY_HIGHEST;
-    else if (r == HIGH_PRIORITY_CLASS)
-      *priority = UV_PRIORITY_HIGH;
-    else if (r == ABOVE_NORMAL_PRIORITY_CLASS)
-      *priority = UV_PRIORITY_ABOVE_NORMAL;
-    else if (r == NORMAL_PRIORITY_CLASS)
-      *priority = UV_PRIORITY_NORMAL;
-    else if (r == BELOW_NORMAL_PRIORITY_CLASS)
-      *priority = UV_PRIORITY_BELOW_NORMAL;
-    else  /* IDLE_PRIORITY_CLASS */
-      *priority = UV_PRIORITY_LOW;
-
-    r = 0;
-  }
-
-  CloseHandle(handle);
-  return r;
-}
-
-
-int uv_os_setpriority(uv_pid_t pid, int priority) {
-  HANDLE handle;
-  int priority_class;
-  int r;
-
-  /* Map Unix nice values to Windows priority classes. */
-  if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW)
-    return UV_EINVAL;
-  else if (priority < UV_PRIORITY_HIGH)
-    priority_class = REALTIME_PRIORITY_CLASS;
-  else if (priority < UV_PRIORITY_ABOVE_NORMAL)
-    priority_class = HIGH_PRIORITY_CLASS;
-  else if (priority < UV_PRIORITY_NORMAL)
-    priority_class = ABOVE_NORMAL_PRIORITY_CLASS;
-  else if (priority < UV_PRIORITY_BELOW_NORMAL)
-    priority_class = NORMAL_PRIORITY_CLASS;
-  else if (priority < UV_PRIORITY_LOW)
-    priority_class = BELOW_NORMAL_PRIORITY_CLASS;
-  else
-    priority_class = IDLE_PRIORITY_CLASS;
-
-  r = uv__get_handle(pid, PROCESS_SET_INFORMATION, &handle);
-
-  if (r != 0)
-    return r;
-
-  if (SetPriorityClass(handle, priority_class) == 0)
-    r = uv_translate_sys_error(GetLastError());
-
-  CloseHandle(handle);
-  return r;
-}
-
-
-int uv_os_uname(uv_utsname_t* buffer) {
-  /* Implementation loosely based on
-     https://github.com/gagern/gnulib/blob/master/lib/uname.c */
-  OSVERSIONINFOW os_info;
-  SYSTEM_INFO system_info;
-  HKEY registry_key;
-  WCHAR product_name_w[256];
-  DWORD product_name_w_size;
-  int version_size;
-  int processor_level;
-  int r;
-
-  if (buffer == NULL)
-    return UV_EINVAL;
-
-  uv__once_init();
-  os_info.dwOSVersionInfoSize = sizeof(os_info);
-  os_info.szCSDVersion[0] = L'\0';
-
-  /* Try calling RtlGetVersion(), and fall back to the deprecated GetVersionEx()
-     if RtlGetVersion() is not available. */
-  if (pRtlGetVersion) {
-    pRtlGetVersion(&os_info);
-  } else {
-    /* Silence GetVersionEx() deprecation warning. */
-    #pragma warning(suppress : 4996)
-    if (GetVersionExW(&os_info) == 0) {
-      r = uv_translate_sys_error(GetLastError());
-      goto error;
-    }
-  }
-
-  /* Populate the version field. */
-  version_size = 0;
-  r = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
-                    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
-                    0,
-                    KEY_QUERY_VALUE,
-                    &registry_key);
-
-  if (r == ERROR_SUCCESS) {
-    product_name_w_size = sizeof(product_name_w);
-    r = RegGetValueW(registry_key,
-                     NULL,
-                     L"ProductName",
-                     RRF_RT_REG_SZ,
-                     NULL,
-                     (PVOID) product_name_w,
-                     &product_name_w_size);
-    RegCloseKey(registry_key);
-
-    if (r == ERROR_SUCCESS) {
-      version_size = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         product_name_w,
-                                         -1,
-                                         buffer->version,
-                                         sizeof(buffer->version),
-                                         NULL,
-                                         NULL);
-      if (version_size == 0) {
-        r = uv_translate_sys_error(GetLastError());
-        goto error;
-      }
-    }
-  }
-
-  /* Append service pack information to the version if present. */
-  if (os_info.szCSDVersion[0] != L'\0') {
-    if (version_size > 0)
-      buffer->version[version_size - 1] = ' ';
-
-    if (WideCharToMultiByte(CP_UTF8,
-                            0,
-                            os_info.szCSDVersion,
-                            -1,
-                            buffer->version + version_size,
-                            sizeof(buffer->version) - version_size,
-                            NULL,
-                            NULL) == 0) {
-      r = uv_translate_sys_error(GetLastError());
-      goto error;
-    }
-  }
-
-  /* Populate the sysname field. */
-#ifdef __MINGW32__
-  r = snprintf(buffer->sysname,
-               sizeof(buffer->sysname),
-               "MINGW32_NT-%u.%u",
-               (unsigned int) os_info.dwMajorVersion,
-               (unsigned int) os_info.dwMinorVersion);
-  assert(r < sizeof(buffer->sysname));
-#else
-  uv__strscpy(buffer->sysname, "Windows_NT", sizeof(buffer->sysname));
-#endif
-
-  /* Populate the release field. */
-  r = snprintf(buffer->release,
-               sizeof(buffer->release),
-               "%d.%d.%d",
-               (unsigned int) os_info.dwMajorVersion,
-               (unsigned int) os_info.dwMinorVersion,
-               (unsigned int) os_info.dwBuildNumber);
-  assert(r < sizeof(buffer->release));
-
-  /* Populate the machine field. */
-  GetSystemInfo(&system_info);
-
-  switch (system_info.wProcessorArchitecture) {
-    case PROCESSOR_ARCHITECTURE_AMD64:
-      uv__strscpy(buffer->machine, "x86_64", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_IA64:
-      uv__strscpy(buffer->machine, "ia64", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_INTEL:
-      uv__strscpy(buffer->machine, "i386", sizeof(buffer->machine));
-
-      if (system_info.wProcessorLevel > 3) {
-        processor_level = system_info.wProcessorLevel < 6 ?
-                          system_info.wProcessorLevel : 6;
-        buffer->machine[1] = '0' + processor_level;
-      }
-
-      break;
-    case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
-      uv__strscpy(buffer->machine, "i686", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_MIPS:
-      uv__strscpy(buffer->machine, "mips", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_ALPHA:
-    case PROCESSOR_ARCHITECTURE_ALPHA64:
-      uv__strscpy(buffer->machine, "alpha", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_PPC:
-      uv__strscpy(buffer->machine, "powerpc", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_SHX:
-      uv__strscpy(buffer->machine, "sh", sizeof(buffer->machine));
-      break;
-    case PROCESSOR_ARCHITECTURE_ARM:
-      uv__strscpy(buffer->machine, "arm", sizeof(buffer->machine));
-      break;
-    default:
-      uv__strscpy(buffer->machine, "unknown", sizeof(buffer->machine));
-      break;
-  }
-
-  return 0;
-
-error:
-  buffer->sysname[0] = '\0';
-  buffer->release[0] = '\0';
-  buffer->version[0] = '\0';
-  buffer->machine[0] = '\0';
-  return r;
-}
-
-int uv_gettimeofday(uv_timeval64_t* tv) {
-  /* Based on https://doxygen.postgresql.org/gettimeofday_8c_source.html */
-  const uint64_t epoch = (uint64_t) 116444736000000000ULL;
-  FILETIME file_time;
-  ULARGE_INTEGER ularge;
-
-  if (tv == NULL)
-    return UV_EINVAL;
-
-  GetSystemTimeAsFileTime(&file_time);
-  ularge.LowPart = file_time.dwLowDateTime;
-  ularge.HighPart = file_time.dwHighDateTime;
-  tv->tv_sec = (int64_t) ((ularge.QuadPart - epoch) / 10000000L);
-  tv->tv_usec = (int32_t) (((ularge.QuadPart - epoch) % 10000000L) / 10);
-  return 0;
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/winapi.cpp b/wpiutil/src/main/native/libuv/src/win/winapi.cpp
deleted file mode 100644
index fbbbcee..0000000
--- a/wpiutil/src/main/native/libuv/src/win/winapi.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-/* Ntdll function pointers */
-sRtlGetVersion pRtlGetVersion;
-sRtlNtStatusToDosError pRtlNtStatusToDosError;
-sNtDeviceIoControlFile pNtDeviceIoControlFile;
-sNtQueryInformationFile pNtQueryInformationFile;
-sNtSetInformationFile pNtSetInformationFile;
-sNtQueryVolumeInformationFile pNtQueryVolumeInformationFile;
-sNtQueryDirectoryFile pNtQueryDirectoryFile;
-sNtQuerySystemInformation pNtQuerySystemInformation;
-
-/* Kernel32 function pointers */
-sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx;
-
-/* Powrprof.dll function pointer */
-sPowerRegisterSuspendResumeNotification pPowerRegisterSuspendResumeNotification;
-
-/* User32.dll function pointer */
-sSetWinEventHook pSetWinEventHook;
-
-
-void uv_winapi_init(void) {
-  HMODULE ntdll_module;
-  HMODULE powrprof_module;
-  HMODULE user32_module;
-  HMODULE kernel32_module;
-
-  ntdll_module = GetModuleHandleA("ntdll.dll");
-  if (ntdll_module == NULL) {
-    uv_fatal_error(GetLastError(), "GetModuleHandleA");
-  }
-
-  pRtlGetVersion = (sRtlGetVersion) GetProcAddress(ntdll_module,
-                                                   "RtlGetVersion");
-
-  pRtlNtStatusToDosError = (sRtlNtStatusToDosError) GetProcAddress(
-      ntdll_module,
-      "RtlNtStatusToDosError");
-  if (pRtlNtStatusToDosError == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtDeviceIoControlFile = (sNtDeviceIoControlFile) GetProcAddress(
-      ntdll_module,
-      "NtDeviceIoControlFile");
-  if (pNtDeviceIoControlFile == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtQueryInformationFile = (sNtQueryInformationFile) GetProcAddress(
-      ntdll_module,
-      "NtQueryInformationFile");
-  if (pNtQueryInformationFile == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtSetInformationFile = (sNtSetInformationFile) GetProcAddress(
-      ntdll_module,
-      "NtSetInformationFile");
-  if (pNtSetInformationFile == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtQueryVolumeInformationFile = (sNtQueryVolumeInformationFile)
-      GetProcAddress(ntdll_module, "NtQueryVolumeInformationFile");
-  if (pNtQueryVolumeInformationFile == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtQueryDirectoryFile = (sNtQueryDirectoryFile)
-      GetProcAddress(ntdll_module, "NtQueryDirectoryFile");
-  if (pNtQueryVolumeInformationFile == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  pNtQuerySystemInformation = (sNtQuerySystemInformation) GetProcAddress(
-      ntdll_module,
-      "NtQuerySystemInformation");
-  if (pNtQuerySystemInformation == NULL) {
-    uv_fatal_error(GetLastError(), "GetProcAddress");
-  }
-
-  kernel32_module = GetModuleHandleA("kernel32.dll");
-  if (kernel32_module == NULL) {
-    uv_fatal_error(GetLastError(), "GetModuleHandleA");
-  }
-
-  pGetQueuedCompletionStatusEx = (sGetQueuedCompletionStatusEx) GetProcAddress(
-      kernel32_module,
-      "GetQueuedCompletionStatusEx");
-
-  powrprof_module = LoadLibraryA("powrprof.dll");
-  if (powrprof_module != NULL) {
-    pPowerRegisterSuspendResumeNotification = (sPowerRegisterSuspendResumeNotification)
-      GetProcAddress(powrprof_module, "PowerRegisterSuspendResumeNotification");
-  }
-
-  user32_module = LoadLibraryA("user32.dll");
-  if (user32_module != NULL) {
-    pSetWinEventHook = (sSetWinEventHook)
-      GetProcAddress(user32_module, "SetWinEventHook");
-  }
-
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/winapi.h b/wpiutil/src/main/native/libuv/src/win/winapi.h
deleted file mode 100644
index 82c5ed4..0000000
--- a/wpiutil/src/main/native/libuv/src/win/winapi.h
+++ /dev/null
@@ -1,4731 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_WINAPI_H_
-#define UV_WIN_WINAPI_H_
-
-#include <windows.h>
-
-
-/*
- * Ntdll headers
- */
-#ifndef STATUS_SEVERITY_SUCCESS
-# define STATUS_SEVERITY_SUCCESS 0x0
-#endif
-
-#ifndef STATUS_SEVERITY_INFORMATIONAL
-# define STATUS_SEVERITY_INFORMATIONAL 0x1
-#endif
-
-#ifndef STATUS_SEVERITY_WARNING
-# define STATUS_SEVERITY_WARNING 0x2
-#endif
-
-#ifndef STATUS_SEVERITY_ERROR
-# define STATUS_SEVERITY_ERROR 0x3
-#endif
-
-#ifndef FACILITY_NTWIN32
-# define FACILITY_NTWIN32 0x7
-#endif
-
-#ifndef NT_SUCCESS
-# define NT_SUCCESS(status) (((NTSTATUS) (status)) >= 0)
-#endif
-
-#ifndef NT_INFORMATION
-# define NT_INFORMATION(status) ((((ULONG) (status)) >> 30) == 1)
-#endif
-
-#ifndef NT_WARNING
-# define NT_WARNING(status) ((((ULONG) (status)) >> 30) == 2)
-#endif
-
-#ifndef NT_ERROR
-# define NT_ERROR(status) ((((ULONG) (status)) >> 30) == 3)
-#endif
-
-#ifndef STATUS_SUCCESS
-# define STATUS_SUCCESS ((NTSTATUS) 0x00000000L)
-#endif
-
-#ifndef STATUS_WAIT_0
-# define STATUS_WAIT_0 ((NTSTATUS) 0x00000000L)
-#endif
-
-#ifndef STATUS_WAIT_1
-# define STATUS_WAIT_1 ((NTSTATUS) 0x00000001L)
-#endif
-
-#ifndef STATUS_WAIT_2
-# define STATUS_WAIT_2 ((NTSTATUS) 0x00000002L)
-#endif
-
-#ifndef STATUS_WAIT_3
-# define STATUS_WAIT_3 ((NTSTATUS) 0x00000003L)
-#endif
-
-#ifndef STATUS_WAIT_63
-# define STATUS_WAIT_63 ((NTSTATUS) 0x0000003FL)
-#endif
-
-#ifndef STATUS_ABANDONED
-# define STATUS_ABANDONED ((NTSTATUS) 0x00000080L)
-#endif
-
-#ifndef STATUS_ABANDONED_WAIT_0
-# define STATUS_ABANDONED_WAIT_0 ((NTSTATUS) 0x00000080L)
-#endif
-
-#ifndef STATUS_ABANDONED_WAIT_63
-# define STATUS_ABANDONED_WAIT_63 ((NTSTATUS) 0x000000BFL)
-#endif
-
-#ifndef STATUS_USER_APC
-# define STATUS_USER_APC ((NTSTATUS) 0x000000C0L)
-#endif
-
-#ifndef STATUS_KERNEL_APC
-# define STATUS_KERNEL_APC ((NTSTATUS) 0x00000100L)
-#endif
-
-#ifndef STATUS_ALERTED
-# define STATUS_ALERTED ((NTSTATUS) 0x00000101L)
-#endif
-
-#ifndef STATUS_TIMEOUT
-# define STATUS_TIMEOUT ((NTSTATUS) 0x00000102L)
-#endif
-
-#ifndef STATUS_PENDING
-# define STATUS_PENDING ((NTSTATUS) 0x00000103L)
-#endif
-
-#ifndef STATUS_REPARSE
-# define STATUS_REPARSE ((NTSTATUS) 0x00000104L)
-#endif
-
-#ifndef STATUS_MORE_ENTRIES
-# define STATUS_MORE_ENTRIES ((NTSTATUS) 0x00000105L)
-#endif
-
-#ifndef STATUS_NOT_ALL_ASSIGNED
-# define STATUS_NOT_ALL_ASSIGNED ((NTSTATUS) 0x00000106L)
-#endif
-
-#ifndef STATUS_SOME_NOT_MAPPED
-# define STATUS_SOME_NOT_MAPPED ((NTSTATUS) 0x00000107L)
-#endif
-
-#ifndef STATUS_OPLOCK_BREAK_IN_PROGRESS
-# define STATUS_OPLOCK_BREAK_IN_PROGRESS ((NTSTATUS) 0x00000108L)
-#endif
-
-#ifndef STATUS_VOLUME_MOUNTED
-# define STATUS_VOLUME_MOUNTED ((NTSTATUS) 0x00000109L)
-#endif
-
-#ifndef STATUS_RXACT_COMMITTED
-# define STATUS_RXACT_COMMITTED ((NTSTATUS) 0x0000010AL)
-#endif
-
-#ifndef STATUS_NOTIFY_CLEANUP
-# define STATUS_NOTIFY_CLEANUP ((NTSTATUS) 0x0000010BL)
-#endif
-
-#ifndef STATUS_NOTIFY_ENUM_DIR
-# define STATUS_NOTIFY_ENUM_DIR ((NTSTATUS) 0x0000010CL)
-#endif
-
-#ifndef STATUS_NO_QUOTAS_FOR_ACCOUNT
-# define STATUS_NO_QUOTAS_FOR_ACCOUNT ((NTSTATUS) 0x0000010DL)
-#endif
-
-#ifndef STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED
-# define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED ((NTSTATUS) 0x0000010EL)
-#endif
-
-#ifndef STATUS_PAGE_FAULT_TRANSITION
-# define STATUS_PAGE_FAULT_TRANSITION ((NTSTATUS) 0x00000110L)
-#endif
-
-#ifndef STATUS_PAGE_FAULT_DEMAND_ZERO
-# define STATUS_PAGE_FAULT_DEMAND_ZERO ((NTSTATUS) 0x00000111L)
-#endif
-
-#ifndef STATUS_PAGE_FAULT_COPY_ON_WRITE
-# define STATUS_PAGE_FAULT_COPY_ON_WRITE ((NTSTATUS) 0x00000112L)
-#endif
-
-#ifndef STATUS_PAGE_FAULT_GUARD_PAGE
-# define STATUS_PAGE_FAULT_GUARD_PAGE ((NTSTATUS) 0x00000113L)
-#endif
-
-#ifndef STATUS_PAGE_FAULT_PAGING_FILE
-# define STATUS_PAGE_FAULT_PAGING_FILE ((NTSTATUS) 0x00000114L)
-#endif
-
-#ifndef STATUS_CACHE_PAGE_LOCKED
-# define STATUS_CACHE_PAGE_LOCKED ((NTSTATUS) 0x00000115L)
-#endif
-
-#ifndef STATUS_CRASH_DUMP
-# define STATUS_CRASH_DUMP ((NTSTATUS) 0x00000116L)
-#endif
-
-#ifndef STATUS_BUFFER_ALL_ZEROS
-# define STATUS_BUFFER_ALL_ZEROS ((NTSTATUS) 0x00000117L)
-#endif
-
-#ifndef STATUS_REPARSE_OBJECT
-# define STATUS_REPARSE_OBJECT ((NTSTATUS) 0x00000118L)
-#endif
-
-#ifndef STATUS_RESOURCE_REQUIREMENTS_CHANGED
-# define STATUS_RESOURCE_REQUIREMENTS_CHANGED ((NTSTATUS) 0x00000119L)
-#endif
-
-#ifndef STATUS_TRANSLATION_COMPLETE
-# define STATUS_TRANSLATION_COMPLETE ((NTSTATUS) 0x00000120L)
-#endif
-
-#ifndef STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY
-# define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY ((NTSTATUS) 0x00000121L)
-#endif
-
-#ifndef STATUS_NOTHING_TO_TERMINATE
-# define STATUS_NOTHING_TO_TERMINATE ((NTSTATUS) 0x00000122L)
-#endif
-
-#ifndef STATUS_PROCESS_NOT_IN_JOB
-# define STATUS_PROCESS_NOT_IN_JOB ((NTSTATUS) 0x00000123L)
-#endif
-
-#ifndef STATUS_PROCESS_IN_JOB
-# define STATUS_PROCESS_IN_JOB ((NTSTATUS) 0x00000124L)
-#endif
-
-#ifndef STATUS_VOLSNAP_HIBERNATE_READY
-# define STATUS_VOLSNAP_HIBERNATE_READY ((NTSTATUS) 0x00000125L)
-#endif
-
-#ifndef STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY
-# define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY ((NTSTATUS) 0x00000126L)
-#endif
-
-#ifndef STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED
-# define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED ((NTSTATUS) 0x00000127L)
-#endif
-
-#ifndef STATUS_INTERRUPT_STILL_CONNECTED
-# define STATUS_INTERRUPT_STILL_CONNECTED ((NTSTATUS) 0x00000128L)
-#endif
-
-#ifndef STATUS_PROCESS_CLONED
-# define STATUS_PROCESS_CLONED ((NTSTATUS) 0x00000129L)
-#endif
-
-#ifndef STATUS_FILE_LOCKED_WITH_ONLY_READERS
-# define STATUS_FILE_LOCKED_WITH_ONLY_READERS ((NTSTATUS) 0x0000012AL)
-#endif
-
-#ifndef STATUS_FILE_LOCKED_WITH_WRITERS
-# define STATUS_FILE_LOCKED_WITH_WRITERS ((NTSTATUS) 0x0000012BL)
-#endif
-
-#ifndef STATUS_RESOURCEMANAGER_READ_ONLY
-# define STATUS_RESOURCEMANAGER_READ_ONLY ((NTSTATUS) 0x00000202L)
-#endif
-
-#ifndef STATUS_RING_PREVIOUSLY_EMPTY
-# define STATUS_RING_PREVIOUSLY_EMPTY ((NTSTATUS) 0x00000210L)
-#endif
-
-#ifndef STATUS_RING_PREVIOUSLY_FULL
-# define STATUS_RING_PREVIOUSLY_FULL ((NTSTATUS) 0x00000211L)
-#endif
-
-#ifndef STATUS_RING_PREVIOUSLY_ABOVE_QUOTA
-# define STATUS_RING_PREVIOUSLY_ABOVE_QUOTA ((NTSTATUS) 0x00000212L)
-#endif
-
-#ifndef STATUS_RING_NEWLY_EMPTY
-# define STATUS_RING_NEWLY_EMPTY ((NTSTATUS) 0x00000213L)
-#endif
-
-#ifndef STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT
-# define STATUS_RING_SIGNAL_OPPOSITE_ENDPOINT ((NTSTATUS) 0x00000214L)
-#endif
-
-#ifndef STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE
-# define STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE ((NTSTATUS) 0x00000215L)
-#endif
-
-#ifndef STATUS_OPLOCK_HANDLE_CLOSED
-# define STATUS_OPLOCK_HANDLE_CLOSED ((NTSTATUS) 0x00000216L)
-#endif
-
-#ifndef STATUS_WAIT_FOR_OPLOCK
-# define STATUS_WAIT_FOR_OPLOCK ((NTSTATUS) 0x00000367L)
-#endif
-
-#ifndef STATUS_OBJECT_NAME_EXISTS
-# define STATUS_OBJECT_NAME_EXISTS ((NTSTATUS) 0x40000000L)
-#endif
-
-#ifndef STATUS_THREAD_WAS_SUSPENDED
-# define STATUS_THREAD_WAS_SUSPENDED ((NTSTATUS) 0x40000001L)
-#endif
-
-#ifndef STATUS_WORKING_SET_LIMIT_RANGE
-# define STATUS_WORKING_SET_LIMIT_RANGE ((NTSTATUS) 0x40000002L)
-#endif
-
-#ifndef STATUS_IMAGE_NOT_AT_BASE
-# define STATUS_IMAGE_NOT_AT_BASE ((NTSTATUS) 0x40000003L)
-#endif
-
-#ifndef STATUS_RXACT_STATE_CREATED
-# define STATUS_RXACT_STATE_CREATED ((NTSTATUS) 0x40000004L)
-#endif
-
-#ifndef STATUS_SEGMENT_NOTIFICATION
-# define STATUS_SEGMENT_NOTIFICATION ((NTSTATUS) 0x40000005L)
-#endif
-
-#ifndef STATUS_LOCAL_USER_SESSION_KEY
-# define STATUS_LOCAL_USER_SESSION_KEY ((NTSTATUS) 0x40000006L)
-#endif
-
-#ifndef STATUS_BAD_CURRENT_DIRECTORY
-# define STATUS_BAD_CURRENT_DIRECTORY ((NTSTATUS) 0x40000007L)
-#endif
-
-#ifndef STATUS_SERIAL_MORE_WRITES
-# define STATUS_SERIAL_MORE_WRITES ((NTSTATUS) 0x40000008L)
-#endif
-
-#ifndef STATUS_REGISTRY_RECOVERED
-# define STATUS_REGISTRY_RECOVERED ((NTSTATUS) 0x40000009L)
-#endif
-
-#ifndef STATUS_FT_READ_RECOVERY_FROM_BACKUP
-# define STATUS_FT_READ_RECOVERY_FROM_BACKUP ((NTSTATUS) 0x4000000AL)
-#endif
-
-#ifndef STATUS_FT_WRITE_RECOVERY
-# define STATUS_FT_WRITE_RECOVERY ((NTSTATUS) 0x4000000BL)
-#endif
-
-#ifndef STATUS_SERIAL_COUNTER_TIMEOUT
-# define STATUS_SERIAL_COUNTER_TIMEOUT ((NTSTATUS) 0x4000000CL)
-#endif
-
-#ifndef STATUS_NULL_LM_PASSWORD
-# define STATUS_NULL_LM_PASSWORD ((NTSTATUS) 0x4000000DL)
-#endif
-
-#ifndef STATUS_IMAGE_MACHINE_TYPE_MISMATCH
-# define STATUS_IMAGE_MACHINE_TYPE_MISMATCH ((NTSTATUS) 0x4000000EL)
-#endif
-
-#ifndef STATUS_RECEIVE_PARTIAL
-# define STATUS_RECEIVE_PARTIAL ((NTSTATUS) 0x4000000FL)
-#endif
-
-#ifndef STATUS_RECEIVE_EXPEDITED
-# define STATUS_RECEIVE_EXPEDITED ((NTSTATUS) 0x40000010L)
-#endif
-
-#ifndef STATUS_RECEIVE_PARTIAL_EXPEDITED
-# define STATUS_RECEIVE_PARTIAL_EXPEDITED ((NTSTATUS) 0x40000011L)
-#endif
-
-#ifndef STATUS_EVENT_DONE
-# define STATUS_EVENT_DONE ((NTSTATUS) 0x40000012L)
-#endif
-
-#ifndef STATUS_EVENT_PENDING
-# define STATUS_EVENT_PENDING ((NTSTATUS) 0x40000013L)
-#endif
-
-#ifndef STATUS_CHECKING_FILE_SYSTEM
-# define STATUS_CHECKING_FILE_SYSTEM ((NTSTATUS) 0x40000014L)
-#endif
-
-#ifndef STATUS_FATAL_APP_EXIT
-# define STATUS_FATAL_APP_EXIT ((NTSTATUS) 0x40000015L)
-#endif
-
-#ifndef STATUS_PREDEFINED_HANDLE
-# define STATUS_PREDEFINED_HANDLE ((NTSTATUS) 0x40000016L)
-#endif
-
-#ifndef STATUS_WAS_UNLOCKED
-# define STATUS_WAS_UNLOCKED ((NTSTATUS) 0x40000017L)
-#endif
-
-#ifndef STATUS_SERVICE_NOTIFICATION
-# define STATUS_SERVICE_NOTIFICATION ((NTSTATUS) 0x40000018L)
-#endif
-
-#ifndef STATUS_WAS_LOCKED
-# define STATUS_WAS_LOCKED ((NTSTATUS) 0x40000019L)
-#endif
-
-#ifndef STATUS_LOG_HARD_ERROR
-# define STATUS_LOG_HARD_ERROR ((NTSTATUS) 0x4000001AL)
-#endif
-
-#ifndef STATUS_ALREADY_WIN32
-# define STATUS_ALREADY_WIN32 ((NTSTATUS) 0x4000001BL)
-#endif
-
-#ifndef STATUS_WX86_UNSIMULATE
-# define STATUS_WX86_UNSIMULATE ((NTSTATUS) 0x4000001CL)
-#endif
-
-#ifndef STATUS_WX86_CONTINUE
-# define STATUS_WX86_CONTINUE ((NTSTATUS) 0x4000001DL)
-#endif
-
-#ifndef STATUS_WX86_SINGLE_STEP
-# define STATUS_WX86_SINGLE_STEP ((NTSTATUS) 0x4000001EL)
-#endif
-
-#ifndef STATUS_WX86_BREAKPOINT
-# define STATUS_WX86_BREAKPOINT ((NTSTATUS) 0x4000001FL)
-#endif
-
-#ifndef STATUS_WX86_EXCEPTION_CONTINUE
-# define STATUS_WX86_EXCEPTION_CONTINUE ((NTSTATUS) 0x40000020L)
-#endif
-
-#ifndef STATUS_WX86_EXCEPTION_LASTCHANCE
-# define STATUS_WX86_EXCEPTION_LASTCHANCE ((NTSTATUS) 0x40000021L)
-#endif
-
-#ifndef STATUS_WX86_EXCEPTION_CHAIN
-# define STATUS_WX86_EXCEPTION_CHAIN ((NTSTATUS) 0x40000022L)
-#endif
-
-#ifndef STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE
-# define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE ((NTSTATUS) 0x40000023L)
-#endif
-
-#ifndef STATUS_NO_YIELD_PERFORMED
-# define STATUS_NO_YIELD_PERFORMED ((NTSTATUS) 0x40000024L)
-#endif
-
-#ifndef STATUS_TIMER_RESUME_IGNORED
-# define STATUS_TIMER_RESUME_IGNORED ((NTSTATUS) 0x40000025L)
-#endif
-
-#ifndef STATUS_ARBITRATION_UNHANDLED
-# define STATUS_ARBITRATION_UNHANDLED ((NTSTATUS) 0x40000026L)
-#endif
-
-#ifndef STATUS_CARDBUS_NOT_SUPPORTED
-# define STATUS_CARDBUS_NOT_SUPPORTED ((NTSTATUS) 0x40000027L)
-#endif
-
-#ifndef STATUS_WX86_CREATEWX86TIB
-# define STATUS_WX86_CREATEWX86TIB ((NTSTATUS) 0x40000028L)
-#endif
-
-#ifndef STATUS_MP_PROCESSOR_MISMATCH
-# define STATUS_MP_PROCESSOR_MISMATCH ((NTSTATUS) 0x40000029L)
-#endif
-
-#ifndef STATUS_HIBERNATED
-# define STATUS_HIBERNATED ((NTSTATUS) 0x4000002AL)
-#endif
-
-#ifndef STATUS_RESUME_HIBERNATION
-# define STATUS_RESUME_HIBERNATION ((NTSTATUS) 0x4000002BL)
-#endif
-
-#ifndef STATUS_FIRMWARE_UPDATED
-# define STATUS_FIRMWARE_UPDATED ((NTSTATUS) 0x4000002CL)
-#endif
-
-#ifndef STATUS_DRIVERS_LEAKING_LOCKED_PAGES
-# define STATUS_DRIVERS_LEAKING_LOCKED_PAGES ((NTSTATUS) 0x4000002DL)
-#endif
-
-#ifndef STATUS_MESSAGE_RETRIEVED
-# define STATUS_MESSAGE_RETRIEVED ((NTSTATUS) 0x4000002EL)
-#endif
-
-#ifndef STATUS_SYSTEM_POWERSTATE_TRANSITION
-# define STATUS_SYSTEM_POWERSTATE_TRANSITION ((NTSTATUS) 0x4000002FL)
-#endif
-
-#ifndef STATUS_ALPC_CHECK_COMPLETION_LIST
-# define STATUS_ALPC_CHECK_COMPLETION_LIST ((NTSTATUS) 0x40000030L)
-#endif
-
-#ifndef STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION
-# define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION ((NTSTATUS) 0x40000031L)
-#endif
-
-#ifndef STATUS_ACCESS_AUDIT_BY_POLICY
-# define STATUS_ACCESS_AUDIT_BY_POLICY ((NTSTATUS) 0x40000032L)
-#endif
-
-#ifndef STATUS_ABANDON_HIBERFILE
-# define STATUS_ABANDON_HIBERFILE ((NTSTATUS) 0x40000033L)
-#endif
-
-#ifndef STATUS_BIZRULES_NOT_ENABLED
-# define STATUS_BIZRULES_NOT_ENABLED ((NTSTATUS) 0x40000034L)
-#endif
-
-#ifndef STATUS_GUARD_PAGE_VIOLATION
-# define STATUS_GUARD_PAGE_VIOLATION ((NTSTATUS) 0x80000001L)
-#endif
-
-#ifndef STATUS_DATATYPE_MISALIGNMENT
-# define STATUS_DATATYPE_MISALIGNMENT ((NTSTATUS) 0x80000002L)
-#endif
-
-#ifndef STATUS_BREAKPOINT
-# define STATUS_BREAKPOINT ((NTSTATUS) 0x80000003L)
-#endif
-
-#ifndef STATUS_SINGLE_STEP
-# define STATUS_SINGLE_STEP ((NTSTATUS) 0x80000004L)
-#endif
-
-#ifndef STATUS_BUFFER_OVERFLOW
-# define STATUS_BUFFER_OVERFLOW ((NTSTATUS) 0x80000005L)
-#endif
-
-#ifndef STATUS_NO_MORE_FILES
-# define STATUS_NO_MORE_FILES ((NTSTATUS) 0x80000006L)
-#endif
-
-#ifndef STATUS_WAKE_SYSTEM_DEBUGGER
-# define STATUS_WAKE_SYSTEM_DEBUGGER ((NTSTATUS) 0x80000007L)
-#endif
-
-#ifndef STATUS_HANDLES_CLOSED
-# define STATUS_HANDLES_CLOSED ((NTSTATUS) 0x8000000AL)
-#endif
-
-#ifndef STATUS_NO_INHERITANCE
-# define STATUS_NO_INHERITANCE ((NTSTATUS) 0x8000000BL)
-#endif
-
-#ifndef STATUS_GUID_SUBSTITUTION_MADE
-# define STATUS_GUID_SUBSTITUTION_MADE ((NTSTATUS) 0x8000000CL)
-#endif
-
-#ifndef STATUS_PARTIAL_COPY
-# define STATUS_PARTIAL_COPY ((NTSTATUS) 0x8000000DL)
-#endif
-
-#ifndef STATUS_DEVICE_PAPER_EMPTY
-# define STATUS_DEVICE_PAPER_EMPTY ((NTSTATUS) 0x8000000EL)
-#endif
-
-#ifndef STATUS_DEVICE_POWERED_OFF
-# define STATUS_DEVICE_POWERED_OFF ((NTSTATUS) 0x8000000FL)
-#endif
-
-#ifndef STATUS_DEVICE_OFF_LINE
-# define STATUS_DEVICE_OFF_LINE ((NTSTATUS) 0x80000010L)
-#endif
-
-#ifndef STATUS_DEVICE_BUSY
-# define STATUS_DEVICE_BUSY ((NTSTATUS) 0x80000011L)
-#endif
-
-#ifndef STATUS_NO_MORE_EAS
-# define STATUS_NO_MORE_EAS ((NTSTATUS) 0x80000012L)
-#endif
-
-#ifndef STATUS_INVALID_EA_NAME
-# define STATUS_INVALID_EA_NAME ((NTSTATUS) 0x80000013L)
-#endif
-
-#ifndef STATUS_EA_LIST_INCONSISTENT
-# define STATUS_EA_LIST_INCONSISTENT ((NTSTATUS) 0x80000014L)
-#endif
-
-#ifndef STATUS_INVALID_EA_FLAG
-# define STATUS_INVALID_EA_FLAG ((NTSTATUS) 0x80000015L)
-#endif
-
-#ifndef STATUS_VERIFY_REQUIRED
-# define STATUS_VERIFY_REQUIRED ((NTSTATUS) 0x80000016L)
-#endif
-
-#ifndef STATUS_EXTRANEOUS_INFORMATION
-# define STATUS_EXTRANEOUS_INFORMATION ((NTSTATUS) 0x80000017L)
-#endif
-
-#ifndef STATUS_RXACT_COMMIT_NECESSARY
-# define STATUS_RXACT_COMMIT_NECESSARY ((NTSTATUS) 0x80000018L)
-#endif
-
-#ifndef STATUS_NO_MORE_ENTRIES
-# define STATUS_NO_MORE_ENTRIES ((NTSTATUS) 0x8000001AL)
-#endif
-
-#ifndef STATUS_FILEMARK_DETECTED
-# define STATUS_FILEMARK_DETECTED ((NTSTATUS) 0x8000001BL)
-#endif
-
-#ifndef STATUS_MEDIA_CHANGED
-# define STATUS_MEDIA_CHANGED ((NTSTATUS) 0x8000001CL)
-#endif
-
-#ifndef STATUS_BUS_RESET
-# define STATUS_BUS_RESET ((NTSTATUS) 0x8000001DL)
-#endif
-
-#ifndef STATUS_END_OF_MEDIA
-# define STATUS_END_OF_MEDIA ((NTSTATUS) 0x8000001EL)
-#endif
-
-#ifndef STATUS_BEGINNING_OF_MEDIA
-# define STATUS_BEGINNING_OF_MEDIA ((NTSTATUS) 0x8000001FL)
-#endif
-
-#ifndef STATUS_MEDIA_CHECK
-# define STATUS_MEDIA_CHECK ((NTSTATUS) 0x80000020L)
-#endif
-
-#ifndef STATUS_SETMARK_DETECTED
-# define STATUS_SETMARK_DETECTED ((NTSTATUS) 0x80000021L)
-#endif
-
-#ifndef STATUS_NO_DATA_DETECTED
-# define STATUS_NO_DATA_DETECTED ((NTSTATUS) 0x80000022L)
-#endif
-
-#ifndef STATUS_REDIRECTOR_HAS_OPEN_HANDLES
-# define STATUS_REDIRECTOR_HAS_OPEN_HANDLES ((NTSTATUS) 0x80000023L)
-#endif
-
-#ifndef STATUS_SERVER_HAS_OPEN_HANDLES
-# define STATUS_SERVER_HAS_OPEN_HANDLES ((NTSTATUS) 0x80000024L)
-#endif
-
-#ifndef STATUS_ALREADY_DISCONNECTED
-# define STATUS_ALREADY_DISCONNECTED ((NTSTATUS) 0x80000025L)
-#endif
-
-#ifndef STATUS_LONGJUMP
-# define STATUS_LONGJUMP ((NTSTATUS) 0x80000026L)
-#endif
-
-#ifndef STATUS_CLEANER_CARTRIDGE_INSTALLED
-# define STATUS_CLEANER_CARTRIDGE_INSTALLED ((NTSTATUS) 0x80000027L)
-#endif
-
-#ifndef STATUS_PLUGPLAY_QUERY_VETOED
-# define STATUS_PLUGPLAY_QUERY_VETOED ((NTSTATUS) 0x80000028L)
-#endif
-
-#ifndef STATUS_UNWIND_CONSOLIDATE
-# define STATUS_UNWIND_CONSOLIDATE ((NTSTATUS) 0x80000029L)
-#endif
-
-#ifndef STATUS_REGISTRY_HIVE_RECOVERED
-# define STATUS_REGISTRY_HIVE_RECOVERED ((NTSTATUS) 0x8000002AL)
-#endif
-
-#ifndef STATUS_DLL_MIGHT_BE_INSECURE
-# define STATUS_DLL_MIGHT_BE_INSECURE ((NTSTATUS) 0x8000002BL)
-#endif
-
-#ifndef STATUS_DLL_MIGHT_BE_INCOMPATIBLE
-# define STATUS_DLL_MIGHT_BE_INCOMPATIBLE ((NTSTATUS) 0x8000002CL)
-#endif
-
-#ifndef STATUS_STOPPED_ON_SYMLINK
-# define STATUS_STOPPED_ON_SYMLINK ((NTSTATUS) 0x8000002DL)
-#endif
-
-#ifndef STATUS_CANNOT_GRANT_REQUESTED_OPLOCK
-# define STATUS_CANNOT_GRANT_REQUESTED_OPLOCK ((NTSTATUS) 0x8000002EL)
-#endif
-
-#ifndef STATUS_NO_ACE_CONDITION
-# define STATUS_NO_ACE_CONDITION ((NTSTATUS) 0x8000002FL)
-#endif
-
-#ifndef STATUS_UNSUCCESSFUL
-# define STATUS_UNSUCCESSFUL ((NTSTATUS) 0xC0000001L)
-#endif
-
-#ifndef STATUS_NOT_IMPLEMENTED
-# define STATUS_NOT_IMPLEMENTED ((NTSTATUS) 0xC0000002L)
-#endif
-
-#ifndef STATUS_INVALID_INFO_CLASS
-# define STATUS_INVALID_INFO_CLASS ((NTSTATUS) 0xC0000003L)
-#endif
-
-#ifndef STATUS_INFO_LENGTH_MISMATCH
-# define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS) 0xC0000004L)
-#endif
-
-#ifndef STATUS_ACCESS_VIOLATION
-# define STATUS_ACCESS_VIOLATION ((NTSTATUS) 0xC0000005L)
-#endif
-
-#ifndef STATUS_IN_PAGE_ERROR
-# define STATUS_IN_PAGE_ERROR ((NTSTATUS) 0xC0000006L)
-#endif
-
-#ifndef STATUS_PAGEFILE_QUOTA
-# define STATUS_PAGEFILE_QUOTA ((NTSTATUS) 0xC0000007L)
-#endif
-
-#ifndef STATUS_INVALID_HANDLE
-# define STATUS_INVALID_HANDLE ((NTSTATUS) 0xC0000008L)
-#endif
-
-#ifndef STATUS_BAD_INITIAL_STACK
-# define STATUS_BAD_INITIAL_STACK ((NTSTATUS) 0xC0000009L)
-#endif
-
-#ifndef STATUS_BAD_INITIAL_PC
-# define STATUS_BAD_INITIAL_PC ((NTSTATUS) 0xC000000AL)
-#endif
-
-#ifndef STATUS_INVALID_CID
-# define STATUS_INVALID_CID ((NTSTATUS) 0xC000000BL)
-#endif
-
-#ifndef STATUS_TIMER_NOT_CANCELED
-# define STATUS_TIMER_NOT_CANCELED ((NTSTATUS) 0xC000000CL)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER
-# define STATUS_INVALID_PARAMETER ((NTSTATUS) 0xC000000DL)
-#endif
-
-#ifndef STATUS_NO_SUCH_DEVICE
-# define STATUS_NO_SUCH_DEVICE ((NTSTATUS) 0xC000000EL)
-#endif
-
-#ifndef STATUS_NO_SUCH_FILE
-# define STATUS_NO_SUCH_FILE ((NTSTATUS) 0xC000000FL)
-#endif
-
-#ifndef STATUS_INVALID_DEVICE_REQUEST
-# define STATUS_INVALID_DEVICE_REQUEST ((NTSTATUS) 0xC0000010L)
-#endif
-
-#ifndef STATUS_END_OF_FILE
-# define STATUS_END_OF_FILE ((NTSTATUS) 0xC0000011L)
-#endif
-
-#ifndef STATUS_WRONG_VOLUME
-# define STATUS_WRONG_VOLUME ((NTSTATUS) 0xC0000012L)
-#endif
-
-#ifndef STATUS_NO_MEDIA_IN_DEVICE
-# define STATUS_NO_MEDIA_IN_DEVICE ((NTSTATUS) 0xC0000013L)
-#endif
-
-#ifndef STATUS_UNRECOGNIZED_MEDIA
-# define STATUS_UNRECOGNIZED_MEDIA ((NTSTATUS) 0xC0000014L)
-#endif
-
-#ifndef STATUS_NONEXISTENT_SECTOR
-# define STATUS_NONEXISTENT_SECTOR ((NTSTATUS) 0xC0000015L)
-#endif
-
-#ifndef STATUS_MORE_PROCESSING_REQUIRED
-# define STATUS_MORE_PROCESSING_REQUIRED ((NTSTATUS) 0xC0000016L)
-#endif
-
-#ifndef STATUS_NO_MEMORY
-# define STATUS_NO_MEMORY ((NTSTATUS) 0xC0000017L)
-#endif
-
-#ifndef STATUS_CONFLICTING_ADDRESSES
-# define STATUS_CONFLICTING_ADDRESSES ((NTSTATUS) 0xC0000018L)
-#endif
-
-#ifndef STATUS_NOT_MAPPED_VIEW
-# define STATUS_NOT_MAPPED_VIEW ((NTSTATUS) 0xC0000019L)
-#endif
-
-#ifndef STATUS_UNABLE_TO_FREE_VM
-# define STATUS_UNABLE_TO_FREE_VM ((NTSTATUS) 0xC000001AL)
-#endif
-
-#ifndef STATUS_UNABLE_TO_DELETE_SECTION
-# define STATUS_UNABLE_TO_DELETE_SECTION ((NTSTATUS) 0xC000001BL)
-#endif
-
-#ifndef STATUS_INVALID_SYSTEM_SERVICE
-# define STATUS_INVALID_SYSTEM_SERVICE ((NTSTATUS) 0xC000001CL)
-#endif
-
-#ifndef STATUS_ILLEGAL_INSTRUCTION
-# define STATUS_ILLEGAL_INSTRUCTION ((NTSTATUS) 0xC000001DL)
-#endif
-
-#ifndef STATUS_INVALID_LOCK_SEQUENCE
-# define STATUS_INVALID_LOCK_SEQUENCE ((NTSTATUS) 0xC000001EL)
-#endif
-
-#ifndef STATUS_INVALID_VIEW_SIZE
-# define STATUS_INVALID_VIEW_SIZE ((NTSTATUS) 0xC000001FL)
-#endif
-
-#ifndef STATUS_INVALID_FILE_FOR_SECTION
-# define STATUS_INVALID_FILE_FOR_SECTION ((NTSTATUS) 0xC0000020L)
-#endif
-
-#ifndef STATUS_ALREADY_COMMITTED
-# define STATUS_ALREADY_COMMITTED ((NTSTATUS) 0xC0000021L)
-#endif
-
-#ifndef STATUS_ACCESS_DENIED
-# define STATUS_ACCESS_DENIED ((NTSTATUS) 0xC0000022L)
-#endif
-
-#ifndef STATUS_BUFFER_TOO_SMALL
-# define STATUS_BUFFER_TOO_SMALL ((NTSTATUS) 0xC0000023L)
-#endif
-
-#ifndef STATUS_OBJECT_TYPE_MISMATCH
-# define STATUS_OBJECT_TYPE_MISMATCH ((NTSTATUS) 0xC0000024L)
-#endif
-
-#ifndef STATUS_NONCONTINUABLE_EXCEPTION
-# define STATUS_NONCONTINUABLE_EXCEPTION ((NTSTATUS) 0xC0000025L)
-#endif
-
-#ifndef STATUS_INVALID_DISPOSITION
-# define STATUS_INVALID_DISPOSITION ((NTSTATUS) 0xC0000026L)
-#endif
-
-#ifndef STATUS_UNWIND
-# define STATUS_UNWIND ((NTSTATUS) 0xC0000027L)
-#endif
-
-#ifndef STATUS_BAD_STACK
-# define STATUS_BAD_STACK ((NTSTATUS) 0xC0000028L)
-#endif
-
-#ifndef STATUS_INVALID_UNWIND_TARGET
-# define STATUS_INVALID_UNWIND_TARGET ((NTSTATUS) 0xC0000029L)
-#endif
-
-#ifndef STATUS_NOT_LOCKED
-# define STATUS_NOT_LOCKED ((NTSTATUS) 0xC000002AL)
-#endif
-
-#ifndef STATUS_PARITY_ERROR
-# define STATUS_PARITY_ERROR ((NTSTATUS) 0xC000002BL)
-#endif
-
-#ifndef STATUS_UNABLE_TO_DECOMMIT_VM
-# define STATUS_UNABLE_TO_DECOMMIT_VM ((NTSTATUS) 0xC000002CL)
-#endif
-
-#ifndef STATUS_NOT_COMMITTED
-# define STATUS_NOT_COMMITTED ((NTSTATUS) 0xC000002DL)
-#endif
-
-#ifndef STATUS_INVALID_PORT_ATTRIBUTES
-# define STATUS_INVALID_PORT_ATTRIBUTES ((NTSTATUS) 0xC000002EL)
-#endif
-
-#ifndef STATUS_PORT_MESSAGE_TOO_LONG
-# define STATUS_PORT_MESSAGE_TOO_LONG ((NTSTATUS) 0xC000002FL)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_MIX
-# define STATUS_INVALID_PARAMETER_MIX ((NTSTATUS) 0xC0000030L)
-#endif
-
-#ifndef STATUS_INVALID_QUOTA_LOWER
-# define STATUS_INVALID_QUOTA_LOWER ((NTSTATUS) 0xC0000031L)
-#endif
-
-#ifndef STATUS_DISK_CORRUPT_ERROR
-# define STATUS_DISK_CORRUPT_ERROR ((NTSTATUS) 0xC0000032L)
-#endif
-
-#ifndef STATUS_OBJECT_NAME_INVALID
-# define STATUS_OBJECT_NAME_INVALID ((NTSTATUS) 0xC0000033L)
-#endif
-
-#ifndef STATUS_OBJECT_NAME_NOT_FOUND
-# define STATUS_OBJECT_NAME_NOT_FOUND ((NTSTATUS) 0xC0000034L)
-#endif
-
-#ifndef STATUS_OBJECT_NAME_COLLISION
-# define STATUS_OBJECT_NAME_COLLISION ((NTSTATUS) 0xC0000035L)
-#endif
-
-#ifndef STATUS_PORT_DISCONNECTED
-# define STATUS_PORT_DISCONNECTED ((NTSTATUS) 0xC0000037L)
-#endif
-
-#ifndef STATUS_DEVICE_ALREADY_ATTACHED
-# define STATUS_DEVICE_ALREADY_ATTACHED ((NTSTATUS) 0xC0000038L)
-#endif
-
-#ifndef STATUS_OBJECT_PATH_INVALID
-# define STATUS_OBJECT_PATH_INVALID ((NTSTATUS) 0xC0000039L)
-#endif
-
-#ifndef STATUS_OBJECT_PATH_NOT_FOUND
-# define STATUS_OBJECT_PATH_NOT_FOUND ((NTSTATUS) 0xC000003AL)
-#endif
-
-#ifndef STATUS_OBJECT_PATH_SYNTAX_BAD
-# define STATUS_OBJECT_PATH_SYNTAX_BAD ((NTSTATUS) 0xC000003BL)
-#endif
-
-#ifndef STATUS_DATA_OVERRUN
-# define STATUS_DATA_OVERRUN ((NTSTATUS) 0xC000003CL)
-#endif
-
-#ifndef STATUS_DATA_LATE_ERROR
-# define STATUS_DATA_LATE_ERROR ((NTSTATUS) 0xC000003DL)
-#endif
-
-#ifndef STATUS_DATA_ERROR
-# define STATUS_DATA_ERROR ((NTSTATUS) 0xC000003EL)
-#endif
-
-#ifndef STATUS_CRC_ERROR
-# define STATUS_CRC_ERROR ((NTSTATUS) 0xC000003FL)
-#endif
-
-#ifndef STATUS_SECTION_TOO_BIG
-# define STATUS_SECTION_TOO_BIG ((NTSTATUS) 0xC0000040L)
-#endif
-
-#ifndef STATUS_PORT_CONNECTION_REFUSED
-# define STATUS_PORT_CONNECTION_REFUSED ((NTSTATUS) 0xC0000041L)
-#endif
-
-#ifndef STATUS_INVALID_PORT_HANDLE
-# define STATUS_INVALID_PORT_HANDLE ((NTSTATUS) 0xC0000042L)
-#endif
-
-#ifndef STATUS_SHARING_VIOLATION
-# define STATUS_SHARING_VIOLATION ((NTSTATUS) 0xC0000043L)
-#endif
-
-#ifndef STATUS_QUOTA_EXCEEDED
-# define STATUS_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000044L)
-#endif
-
-#ifndef STATUS_INVALID_PAGE_PROTECTION
-# define STATUS_INVALID_PAGE_PROTECTION ((NTSTATUS) 0xC0000045L)
-#endif
-
-#ifndef STATUS_MUTANT_NOT_OWNED
-# define STATUS_MUTANT_NOT_OWNED ((NTSTATUS) 0xC0000046L)
-#endif
-
-#ifndef STATUS_SEMAPHORE_LIMIT_EXCEEDED
-# define STATUS_SEMAPHORE_LIMIT_EXCEEDED ((NTSTATUS) 0xC0000047L)
-#endif
-
-#ifndef STATUS_PORT_ALREADY_SET
-# define STATUS_PORT_ALREADY_SET ((NTSTATUS) 0xC0000048L)
-#endif
-
-#ifndef STATUS_SECTION_NOT_IMAGE
-# define STATUS_SECTION_NOT_IMAGE ((NTSTATUS) 0xC0000049L)
-#endif
-
-#ifndef STATUS_SUSPEND_COUNT_EXCEEDED
-# define STATUS_SUSPEND_COUNT_EXCEEDED ((NTSTATUS) 0xC000004AL)
-#endif
-
-#ifndef STATUS_THREAD_IS_TERMINATING
-# define STATUS_THREAD_IS_TERMINATING ((NTSTATUS) 0xC000004BL)
-#endif
-
-#ifndef STATUS_BAD_WORKING_SET_LIMIT
-# define STATUS_BAD_WORKING_SET_LIMIT ((NTSTATUS) 0xC000004CL)
-#endif
-
-#ifndef STATUS_INCOMPATIBLE_FILE_MAP
-# define STATUS_INCOMPATIBLE_FILE_MAP ((NTSTATUS) 0xC000004DL)
-#endif
-
-#ifndef STATUS_SECTION_PROTECTION
-# define STATUS_SECTION_PROTECTION ((NTSTATUS) 0xC000004EL)
-#endif
-
-#ifndef STATUS_EAS_NOT_SUPPORTED
-# define STATUS_EAS_NOT_SUPPORTED ((NTSTATUS) 0xC000004FL)
-#endif
-
-#ifndef STATUS_EA_TOO_LARGE
-# define STATUS_EA_TOO_LARGE ((NTSTATUS) 0xC0000050L)
-#endif
-
-#ifndef STATUS_NONEXISTENT_EA_ENTRY
-# define STATUS_NONEXISTENT_EA_ENTRY ((NTSTATUS) 0xC0000051L)
-#endif
-
-#ifndef STATUS_NO_EAS_ON_FILE
-# define STATUS_NO_EAS_ON_FILE ((NTSTATUS) 0xC0000052L)
-#endif
-
-#ifndef STATUS_EA_CORRUPT_ERROR
-# define STATUS_EA_CORRUPT_ERROR ((NTSTATUS) 0xC0000053L)
-#endif
-
-#ifndef STATUS_FILE_LOCK_CONFLICT
-# define STATUS_FILE_LOCK_CONFLICT ((NTSTATUS) 0xC0000054L)
-#endif
-
-#ifndef STATUS_LOCK_NOT_GRANTED
-# define STATUS_LOCK_NOT_GRANTED ((NTSTATUS) 0xC0000055L)
-#endif
-
-#ifndef STATUS_DELETE_PENDING
-# define STATUS_DELETE_PENDING ((NTSTATUS) 0xC0000056L)
-#endif
-
-#ifndef STATUS_CTL_FILE_NOT_SUPPORTED
-# define STATUS_CTL_FILE_NOT_SUPPORTED ((NTSTATUS) 0xC0000057L)
-#endif
-
-#ifndef STATUS_UNKNOWN_REVISION
-# define STATUS_UNKNOWN_REVISION ((NTSTATUS) 0xC0000058L)
-#endif
-
-#ifndef STATUS_REVISION_MISMATCH
-# define STATUS_REVISION_MISMATCH ((NTSTATUS) 0xC0000059L)
-#endif
-
-#ifndef STATUS_INVALID_OWNER
-# define STATUS_INVALID_OWNER ((NTSTATUS) 0xC000005AL)
-#endif
-
-#ifndef STATUS_INVALID_PRIMARY_GROUP
-# define STATUS_INVALID_PRIMARY_GROUP ((NTSTATUS) 0xC000005BL)
-#endif
-
-#ifndef STATUS_NO_IMPERSONATION_TOKEN
-# define STATUS_NO_IMPERSONATION_TOKEN ((NTSTATUS) 0xC000005CL)
-#endif
-
-#ifndef STATUS_CANT_DISABLE_MANDATORY
-# define STATUS_CANT_DISABLE_MANDATORY ((NTSTATUS) 0xC000005DL)
-#endif
-
-#ifndef STATUS_NO_LOGON_SERVERS
-# define STATUS_NO_LOGON_SERVERS ((NTSTATUS) 0xC000005EL)
-#endif
-
-#ifndef STATUS_NO_SUCH_LOGON_SESSION
-# define STATUS_NO_SUCH_LOGON_SESSION ((NTSTATUS) 0xC000005FL)
-#endif
-
-#ifndef STATUS_NO_SUCH_PRIVILEGE
-# define STATUS_NO_SUCH_PRIVILEGE ((NTSTATUS) 0xC0000060L)
-#endif
-
-#ifndef STATUS_PRIVILEGE_NOT_HELD
-# define STATUS_PRIVILEGE_NOT_HELD ((NTSTATUS) 0xC0000061L)
-#endif
-
-#ifndef STATUS_INVALID_ACCOUNT_NAME
-# define STATUS_INVALID_ACCOUNT_NAME ((NTSTATUS) 0xC0000062L)
-#endif
-
-#ifndef STATUS_USER_EXISTS
-# define STATUS_USER_EXISTS ((NTSTATUS) 0xC0000063L)
-#endif
-
-#ifndef STATUS_NO_SUCH_USER
-# define STATUS_NO_SUCH_USER ((NTSTATUS) 0xC0000064L)
-#endif
-
-#ifndef STATUS_GROUP_EXISTS
-# define STATUS_GROUP_EXISTS ((NTSTATUS) 0xC0000065L)
-#endif
-
-#ifndef STATUS_NO_SUCH_GROUP
-# define STATUS_NO_SUCH_GROUP ((NTSTATUS) 0xC0000066L)
-#endif
-
-#ifndef STATUS_MEMBER_IN_GROUP
-# define STATUS_MEMBER_IN_GROUP ((NTSTATUS) 0xC0000067L)
-#endif
-
-#ifndef STATUS_MEMBER_NOT_IN_GROUP
-# define STATUS_MEMBER_NOT_IN_GROUP ((NTSTATUS) 0xC0000068L)
-#endif
-
-#ifndef STATUS_LAST_ADMIN
-# define STATUS_LAST_ADMIN ((NTSTATUS) 0xC0000069L)
-#endif
-
-#ifndef STATUS_WRONG_PASSWORD
-# define STATUS_WRONG_PASSWORD ((NTSTATUS) 0xC000006AL)
-#endif
-
-#ifndef STATUS_ILL_FORMED_PASSWORD
-# define STATUS_ILL_FORMED_PASSWORD ((NTSTATUS) 0xC000006BL)
-#endif
-
-#ifndef STATUS_PASSWORD_RESTRICTION
-# define STATUS_PASSWORD_RESTRICTION ((NTSTATUS) 0xC000006CL)
-#endif
-
-#ifndef STATUS_LOGON_FAILURE
-# define STATUS_LOGON_FAILURE ((NTSTATUS) 0xC000006DL)
-#endif
-
-#ifndef STATUS_ACCOUNT_RESTRICTION
-# define STATUS_ACCOUNT_RESTRICTION ((NTSTATUS) 0xC000006EL)
-#endif
-
-#ifndef STATUS_INVALID_LOGON_HOURS
-# define STATUS_INVALID_LOGON_HOURS ((NTSTATUS) 0xC000006FL)
-#endif
-
-#ifndef STATUS_INVALID_WORKSTATION
-# define STATUS_INVALID_WORKSTATION ((NTSTATUS) 0xC0000070L)
-#endif
-
-#ifndef STATUS_PASSWORD_EXPIRED
-# define STATUS_PASSWORD_EXPIRED ((NTSTATUS) 0xC0000071L)
-#endif
-
-#ifndef STATUS_ACCOUNT_DISABLED
-# define STATUS_ACCOUNT_DISABLED ((NTSTATUS) 0xC0000072L)
-#endif
-
-#ifndef STATUS_NONE_MAPPED
-# define STATUS_NONE_MAPPED ((NTSTATUS) 0xC0000073L)
-#endif
-
-#ifndef STATUS_TOO_MANY_LUIDS_REQUESTED
-# define STATUS_TOO_MANY_LUIDS_REQUESTED ((NTSTATUS) 0xC0000074L)
-#endif
-
-#ifndef STATUS_LUIDS_EXHAUSTED
-# define STATUS_LUIDS_EXHAUSTED ((NTSTATUS) 0xC0000075L)
-#endif
-
-#ifndef STATUS_INVALID_SUB_AUTHORITY
-# define STATUS_INVALID_SUB_AUTHORITY ((NTSTATUS) 0xC0000076L)
-#endif
-
-#ifndef STATUS_INVALID_ACL
-# define STATUS_INVALID_ACL ((NTSTATUS) 0xC0000077L)
-#endif
-
-#ifndef STATUS_INVALID_SID
-# define STATUS_INVALID_SID ((NTSTATUS) 0xC0000078L)
-#endif
-
-#ifndef STATUS_INVALID_SECURITY_DESCR
-# define STATUS_INVALID_SECURITY_DESCR ((NTSTATUS) 0xC0000079L)
-#endif
-
-#ifndef STATUS_PROCEDURE_NOT_FOUND
-# define STATUS_PROCEDURE_NOT_FOUND ((NTSTATUS) 0xC000007AL)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_FORMAT
-# define STATUS_INVALID_IMAGE_FORMAT ((NTSTATUS) 0xC000007BL)
-#endif
-
-#ifndef STATUS_NO_TOKEN
-# define STATUS_NO_TOKEN ((NTSTATUS) 0xC000007CL)
-#endif
-
-#ifndef STATUS_BAD_INHERITANCE_ACL
-# define STATUS_BAD_INHERITANCE_ACL ((NTSTATUS) 0xC000007DL)
-#endif
-
-#ifndef STATUS_RANGE_NOT_LOCKED
-# define STATUS_RANGE_NOT_LOCKED ((NTSTATUS) 0xC000007EL)
-#endif
-
-#ifndef STATUS_DISK_FULL
-# define STATUS_DISK_FULL ((NTSTATUS) 0xC000007FL)
-#endif
-
-#ifndef STATUS_SERVER_DISABLED
-# define STATUS_SERVER_DISABLED ((NTSTATUS) 0xC0000080L)
-#endif
-
-#ifndef STATUS_SERVER_NOT_DISABLED
-# define STATUS_SERVER_NOT_DISABLED ((NTSTATUS) 0xC0000081L)
-#endif
-
-#ifndef STATUS_TOO_MANY_GUIDS_REQUESTED
-# define STATUS_TOO_MANY_GUIDS_REQUESTED ((NTSTATUS) 0xC0000082L)
-#endif
-
-#ifndef STATUS_GUIDS_EXHAUSTED
-# define STATUS_GUIDS_EXHAUSTED ((NTSTATUS) 0xC0000083L)
-#endif
-
-#ifndef STATUS_INVALID_ID_AUTHORITY
-# define STATUS_INVALID_ID_AUTHORITY ((NTSTATUS) 0xC0000084L)
-#endif
-
-#ifndef STATUS_AGENTS_EXHAUSTED
-# define STATUS_AGENTS_EXHAUSTED ((NTSTATUS) 0xC0000085L)
-#endif
-
-#ifndef STATUS_INVALID_VOLUME_LABEL
-# define STATUS_INVALID_VOLUME_LABEL ((NTSTATUS) 0xC0000086L)
-#endif
-
-#ifndef STATUS_SECTION_NOT_EXTENDED
-# define STATUS_SECTION_NOT_EXTENDED ((NTSTATUS) 0xC0000087L)
-#endif
-
-#ifndef STATUS_NOT_MAPPED_DATA
-# define STATUS_NOT_MAPPED_DATA ((NTSTATUS) 0xC0000088L)
-#endif
-
-#ifndef STATUS_RESOURCE_DATA_NOT_FOUND
-# define STATUS_RESOURCE_DATA_NOT_FOUND ((NTSTATUS) 0xC0000089L)
-#endif
-
-#ifndef STATUS_RESOURCE_TYPE_NOT_FOUND
-# define STATUS_RESOURCE_TYPE_NOT_FOUND ((NTSTATUS) 0xC000008AL)
-#endif
-
-#ifndef STATUS_RESOURCE_NAME_NOT_FOUND
-# define STATUS_RESOURCE_NAME_NOT_FOUND ((NTSTATUS) 0xC000008BL)
-#endif
-
-#ifndef STATUS_ARRAY_BOUNDS_EXCEEDED
-# define STATUS_ARRAY_BOUNDS_EXCEEDED ((NTSTATUS) 0xC000008CL)
-#endif
-
-#ifndef STATUS_FLOAT_DENORMAL_OPERAND
-# define STATUS_FLOAT_DENORMAL_OPERAND ((NTSTATUS) 0xC000008DL)
-#endif
-
-#ifndef STATUS_FLOAT_DIVIDE_BY_ZERO
-# define STATUS_FLOAT_DIVIDE_BY_ZERO ((NTSTATUS) 0xC000008EL)
-#endif
-
-#ifndef STATUS_FLOAT_INEXACT_RESULT
-# define STATUS_FLOAT_INEXACT_RESULT ((NTSTATUS) 0xC000008FL)
-#endif
-
-#ifndef STATUS_FLOAT_INVALID_OPERATION
-# define STATUS_FLOAT_INVALID_OPERATION ((NTSTATUS) 0xC0000090L)
-#endif
-
-#ifndef STATUS_FLOAT_OVERFLOW
-# define STATUS_FLOAT_OVERFLOW ((NTSTATUS) 0xC0000091L)
-#endif
-
-#ifndef STATUS_FLOAT_STACK_CHECK
-# define STATUS_FLOAT_STACK_CHECK ((NTSTATUS) 0xC0000092L)
-#endif
-
-#ifndef STATUS_FLOAT_UNDERFLOW
-# define STATUS_FLOAT_UNDERFLOW ((NTSTATUS) 0xC0000093L)
-#endif
-
-#ifndef STATUS_INTEGER_DIVIDE_BY_ZERO
-# define STATUS_INTEGER_DIVIDE_BY_ZERO ((NTSTATUS) 0xC0000094L)
-#endif
-
-#ifndef STATUS_INTEGER_OVERFLOW
-# define STATUS_INTEGER_OVERFLOW ((NTSTATUS) 0xC0000095L)
-#endif
-
-#ifndef STATUS_PRIVILEGED_INSTRUCTION
-# define STATUS_PRIVILEGED_INSTRUCTION ((NTSTATUS) 0xC0000096L)
-#endif
-
-#ifndef STATUS_TOO_MANY_PAGING_FILES
-# define STATUS_TOO_MANY_PAGING_FILES ((NTSTATUS) 0xC0000097L)
-#endif
-
-#ifndef STATUS_FILE_INVALID
-# define STATUS_FILE_INVALID ((NTSTATUS) 0xC0000098L)
-#endif
-
-#ifndef STATUS_ALLOTTED_SPACE_EXCEEDED
-# define STATUS_ALLOTTED_SPACE_EXCEEDED ((NTSTATUS) 0xC0000099L)
-#endif
-
-#ifndef STATUS_INSUFFICIENT_RESOURCES
-# define STATUS_INSUFFICIENT_RESOURCES ((NTSTATUS) 0xC000009AL)
-#endif
-
-#ifndef STATUS_DFS_EXIT_PATH_FOUND
-# define STATUS_DFS_EXIT_PATH_FOUND ((NTSTATUS) 0xC000009BL)
-#endif
-
-#ifndef STATUS_DEVICE_DATA_ERROR
-# define STATUS_DEVICE_DATA_ERROR ((NTSTATUS) 0xC000009CL)
-#endif
-
-#ifndef STATUS_DEVICE_NOT_CONNECTED
-# define STATUS_DEVICE_NOT_CONNECTED ((NTSTATUS) 0xC000009DL)
-#endif
-
-#ifndef STATUS_DEVICE_POWER_FAILURE
-# define STATUS_DEVICE_POWER_FAILURE ((NTSTATUS) 0xC000009EL)
-#endif
-
-#ifndef STATUS_FREE_VM_NOT_AT_BASE
-# define STATUS_FREE_VM_NOT_AT_BASE ((NTSTATUS) 0xC000009FL)
-#endif
-
-#ifndef STATUS_MEMORY_NOT_ALLOCATED
-# define STATUS_MEMORY_NOT_ALLOCATED ((NTSTATUS) 0xC00000A0L)
-#endif
-
-#ifndef STATUS_WORKING_SET_QUOTA
-# define STATUS_WORKING_SET_QUOTA ((NTSTATUS) 0xC00000A1L)
-#endif
-
-#ifndef STATUS_MEDIA_WRITE_PROTECTED
-# define STATUS_MEDIA_WRITE_PROTECTED ((NTSTATUS) 0xC00000A2L)
-#endif
-
-#ifndef STATUS_DEVICE_NOT_READY
-# define STATUS_DEVICE_NOT_READY ((NTSTATUS) 0xC00000A3L)
-#endif
-
-#ifndef STATUS_INVALID_GROUP_ATTRIBUTES
-# define STATUS_INVALID_GROUP_ATTRIBUTES ((NTSTATUS) 0xC00000A4L)
-#endif
-
-#ifndef STATUS_BAD_IMPERSONATION_LEVEL
-# define STATUS_BAD_IMPERSONATION_LEVEL ((NTSTATUS) 0xC00000A5L)
-#endif
-
-#ifndef STATUS_CANT_OPEN_ANONYMOUS
-# define STATUS_CANT_OPEN_ANONYMOUS ((NTSTATUS) 0xC00000A6L)
-#endif
-
-#ifndef STATUS_BAD_VALIDATION_CLASS
-# define STATUS_BAD_VALIDATION_CLASS ((NTSTATUS) 0xC00000A7L)
-#endif
-
-#ifndef STATUS_BAD_TOKEN_TYPE
-# define STATUS_BAD_TOKEN_TYPE ((NTSTATUS) 0xC00000A8L)
-#endif
-
-#ifndef STATUS_BAD_MASTER_BOOT_RECORD
-# define STATUS_BAD_MASTER_BOOT_RECORD ((NTSTATUS) 0xC00000A9L)
-#endif
-
-#ifndef STATUS_INSTRUCTION_MISALIGNMENT
-# define STATUS_INSTRUCTION_MISALIGNMENT ((NTSTATUS) 0xC00000AAL)
-#endif
-
-#ifndef STATUS_INSTANCE_NOT_AVAILABLE
-# define STATUS_INSTANCE_NOT_AVAILABLE ((NTSTATUS) 0xC00000ABL)
-#endif
-
-#ifndef STATUS_PIPE_NOT_AVAILABLE
-# define STATUS_PIPE_NOT_AVAILABLE ((NTSTATUS) 0xC00000ACL)
-#endif
-
-#ifndef STATUS_INVALID_PIPE_STATE
-# define STATUS_INVALID_PIPE_STATE ((NTSTATUS) 0xC00000ADL)
-#endif
-
-#ifndef STATUS_PIPE_BUSY
-# define STATUS_PIPE_BUSY ((NTSTATUS) 0xC00000AEL)
-#endif
-
-#ifndef STATUS_ILLEGAL_FUNCTION
-# define STATUS_ILLEGAL_FUNCTION ((NTSTATUS) 0xC00000AFL)
-#endif
-
-#ifndef STATUS_PIPE_DISCONNECTED
-# define STATUS_PIPE_DISCONNECTED ((NTSTATUS) 0xC00000B0L)
-#endif
-
-#ifndef STATUS_PIPE_CLOSING
-# define STATUS_PIPE_CLOSING ((NTSTATUS) 0xC00000B1L)
-#endif
-
-#ifndef STATUS_PIPE_CONNECTED
-# define STATUS_PIPE_CONNECTED ((NTSTATUS) 0xC00000B2L)
-#endif
-
-#ifndef STATUS_PIPE_LISTENING
-# define STATUS_PIPE_LISTENING ((NTSTATUS) 0xC00000B3L)
-#endif
-
-#ifndef STATUS_INVALID_READ_MODE
-# define STATUS_INVALID_READ_MODE ((NTSTATUS) 0xC00000B4L)
-#endif
-
-#ifndef STATUS_IO_TIMEOUT
-# define STATUS_IO_TIMEOUT ((NTSTATUS) 0xC00000B5L)
-#endif
-
-#ifndef STATUS_FILE_FORCED_CLOSED
-# define STATUS_FILE_FORCED_CLOSED ((NTSTATUS) 0xC00000B6L)
-#endif
-
-#ifndef STATUS_PROFILING_NOT_STARTED
-# define STATUS_PROFILING_NOT_STARTED ((NTSTATUS) 0xC00000B7L)
-#endif
-
-#ifndef STATUS_PROFILING_NOT_STOPPED
-# define STATUS_PROFILING_NOT_STOPPED ((NTSTATUS) 0xC00000B8L)
-#endif
-
-#ifndef STATUS_COULD_NOT_INTERPRET
-# define STATUS_COULD_NOT_INTERPRET ((NTSTATUS) 0xC00000B9L)
-#endif
-
-#ifndef STATUS_FILE_IS_A_DIRECTORY
-# define STATUS_FILE_IS_A_DIRECTORY ((NTSTATUS) 0xC00000BAL)
-#endif
-
-#ifndef STATUS_NOT_SUPPORTED
-# define STATUS_NOT_SUPPORTED ((NTSTATUS) 0xC00000BBL)
-#endif
-
-#ifndef STATUS_REMOTE_NOT_LISTENING
-# define STATUS_REMOTE_NOT_LISTENING ((NTSTATUS) 0xC00000BCL)
-#endif
-
-#ifndef STATUS_DUPLICATE_NAME
-# define STATUS_DUPLICATE_NAME ((NTSTATUS) 0xC00000BDL)
-#endif
-
-#ifndef STATUS_BAD_NETWORK_PATH
-# define STATUS_BAD_NETWORK_PATH ((NTSTATUS) 0xC00000BEL)
-#endif
-
-#ifndef STATUS_NETWORK_BUSY
-# define STATUS_NETWORK_BUSY ((NTSTATUS) 0xC00000BFL)
-#endif
-
-#ifndef STATUS_DEVICE_DOES_NOT_EXIST
-# define STATUS_DEVICE_DOES_NOT_EXIST ((NTSTATUS) 0xC00000C0L)
-#endif
-
-#ifndef STATUS_TOO_MANY_COMMANDS
-# define STATUS_TOO_MANY_COMMANDS ((NTSTATUS) 0xC00000C1L)
-#endif
-
-#ifndef STATUS_ADAPTER_HARDWARE_ERROR
-# define STATUS_ADAPTER_HARDWARE_ERROR ((NTSTATUS) 0xC00000C2L)
-#endif
-
-#ifndef STATUS_INVALID_NETWORK_RESPONSE
-# define STATUS_INVALID_NETWORK_RESPONSE ((NTSTATUS) 0xC00000C3L)
-#endif
-
-#ifndef STATUS_UNEXPECTED_NETWORK_ERROR
-# define STATUS_UNEXPECTED_NETWORK_ERROR ((NTSTATUS) 0xC00000C4L)
-#endif
-
-#ifndef STATUS_BAD_REMOTE_ADAPTER
-# define STATUS_BAD_REMOTE_ADAPTER ((NTSTATUS) 0xC00000C5L)
-#endif
-
-#ifndef STATUS_PRINT_QUEUE_FULL
-# define STATUS_PRINT_QUEUE_FULL ((NTSTATUS) 0xC00000C6L)
-#endif
-
-#ifndef STATUS_NO_SPOOL_SPACE
-# define STATUS_NO_SPOOL_SPACE ((NTSTATUS) 0xC00000C7L)
-#endif
-
-#ifndef STATUS_PRINT_CANCELLED
-# define STATUS_PRINT_CANCELLED ((NTSTATUS) 0xC00000C8L)
-#endif
-
-#ifndef STATUS_NETWORK_NAME_DELETED
-# define STATUS_NETWORK_NAME_DELETED ((NTSTATUS) 0xC00000C9L)
-#endif
-
-#ifndef STATUS_NETWORK_ACCESS_DENIED
-# define STATUS_NETWORK_ACCESS_DENIED ((NTSTATUS) 0xC00000CAL)
-#endif
-
-#ifndef STATUS_BAD_DEVICE_TYPE
-# define STATUS_BAD_DEVICE_TYPE ((NTSTATUS) 0xC00000CBL)
-#endif
-
-#ifndef STATUS_BAD_NETWORK_NAME
-# define STATUS_BAD_NETWORK_NAME ((NTSTATUS) 0xC00000CCL)
-#endif
-
-#ifndef STATUS_TOO_MANY_NAMES
-# define STATUS_TOO_MANY_NAMES ((NTSTATUS) 0xC00000CDL)
-#endif
-
-#ifndef STATUS_TOO_MANY_SESSIONS
-# define STATUS_TOO_MANY_SESSIONS ((NTSTATUS) 0xC00000CEL)
-#endif
-
-#ifndef STATUS_SHARING_PAUSED
-# define STATUS_SHARING_PAUSED ((NTSTATUS) 0xC00000CFL)
-#endif
-
-#ifndef STATUS_REQUEST_NOT_ACCEPTED
-# define STATUS_REQUEST_NOT_ACCEPTED ((NTSTATUS) 0xC00000D0L)
-#endif
-
-#ifndef STATUS_REDIRECTOR_PAUSED
-# define STATUS_REDIRECTOR_PAUSED ((NTSTATUS) 0xC00000D1L)
-#endif
-
-#ifndef STATUS_NET_WRITE_FAULT
-# define STATUS_NET_WRITE_FAULT ((NTSTATUS) 0xC00000D2L)
-#endif
-
-#ifndef STATUS_PROFILING_AT_LIMIT
-# define STATUS_PROFILING_AT_LIMIT ((NTSTATUS) 0xC00000D3L)
-#endif
-
-#ifndef STATUS_NOT_SAME_DEVICE
-# define STATUS_NOT_SAME_DEVICE ((NTSTATUS) 0xC00000D4L)
-#endif
-
-#ifndef STATUS_FILE_RENAMED
-# define STATUS_FILE_RENAMED ((NTSTATUS) 0xC00000D5L)
-#endif
-
-#ifndef STATUS_VIRTUAL_CIRCUIT_CLOSED
-# define STATUS_VIRTUAL_CIRCUIT_CLOSED ((NTSTATUS) 0xC00000D6L)
-#endif
-
-#ifndef STATUS_NO_SECURITY_ON_OBJECT
-# define STATUS_NO_SECURITY_ON_OBJECT ((NTSTATUS) 0xC00000D7L)
-#endif
-
-#ifndef STATUS_CANT_WAIT
-# define STATUS_CANT_WAIT ((NTSTATUS) 0xC00000D8L)
-#endif
-
-#ifndef STATUS_PIPE_EMPTY
-# define STATUS_PIPE_EMPTY ((NTSTATUS) 0xC00000D9L)
-#endif
-
-#ifndef STATUS_CANT_ACCESS_DOMAIN_INFO
-# define STATUS_CANT_ACCESS_DOMAIN_INFO ((NTSTATUS) 0xC00000DAL)
-#endif
-
-#ifndef STATUS_CANT_TERMINATE_SELF
-# define STATUS_CANT_TERMINATE_SELF ((NTSTATUS) 0xC00000DBL)
-#endif
-
-#ifndef STATUS_INVALID_SERVER_STATE
-# define STATUS_INVALID_SERVER_STATE ((NTSTATUS) 0xC00000DCL)
-#endif
-
-#ifndef STATUS_INVALID_DOMAIN_STATE
-# define STATUS_INVALID_DOMAIN_STATE ((NTSTATUS) 0xC00000DDL)
-#endif
-
-#ifndef STATUS_INVALID_DOMAIN_ROLE
-# define STATUS_INVALID_DOMAIN_ROLE ((NTSTATUS) 0xC00000DEL)
-#endif
-
-#ifndef STATUS_NO_SUCH_DOMAIN
-# define STATUS_NO_SUCH_DOMAIN ((NTSTATUS) 0xC00000DFL)
-#endif
-
-#ifndef STATUS_DOMAIN_EXISTS
-# define STATUS_DOMAIN_EXISTS ((NTSTATUS) 0xC00000E0L)
-#endif
-
-#ifndef STATUS_DOMAIN_LIMIT_EXCEEDED
-# define STATUS_DOMAIN_LIMIT_EXCEEDED ((NTSTATUS) 0xC00000E1L)
-#endif
-
-#ifndef STATUS_OPLOCK_NOT_GRANTED
-# define STATUS_OPLOCK_NOT_GRANTED ((NTSTATUS) 0xC00000E2L)
-#endif
-
-#ifndef STATUS_INVALID_OPLOCK_PROTOCOL
-# define STATUS_INVALID_OPLOCK_PROTOCOL ((NTSTATUS) 0xC00000E3L)
-#endif
-
-#ifndef STATUS_INTERNAL_DB_CORRUPTION
-# define STATUS_INTERNAL_DB_CORRUPTION ((NTSTATUS) 0xC00000E4L)
-#endif
-
-#ifndef STATUS_INTERNAL_ERROR
-# define STATUS_INTERNAL_ERROR ((NTSTATUS) 0xC00000E5L)
-#endif
-
-#ifndef STATUS_GENERIC_NOT_MAPPED
-# define STATUS_GENERIC_NOT_MAPPED ((NTSTATUS) 0xC00000E6L)
-#endif
-
-#ifndef STATUS_BAD_DESCRIPTOR_FORMAT
-# define STATUS_BAD_DESCRIPTOR_FORMAT ((NTSTATUS) 0xC00000E7L)
-#endif
-
-#ifndef STATUS_INVALID_USER_BUFFER
-# define STATUS_INVALID_USER_BUFFER ((NTSTATUS) 0xC00000E8L)
-#endif
-
-#ifndef STATUS_UNEXPECTED_IO_ERROR
-# define STATUS_UNEXPECTED_IO_ERROR ((NTSTATUS) 0xC00000E9L)
-#endif
-
-#ifndef STATUS_UNEXPECTED_MM_CREATE_ERR
-# define STATUS_UNEXPECTED_MM_CREATE_ERR ((NTSTATUS) 0xC00000EAL)
-#endif
-
-#ifndef STATUS_UNEXPECTED_MM_MAP_ERROR
-# define STATUS_UNEXPECTED_MM_MAP_ERROR ((NTSTATUS) 0xC00000EBL)
-#endif
-
-#ifndef STATUS_UNEXPECTED_MM_EXTEND_ERR
-# define STATUS_UNEXPECTED_MM_EXTEND_ERR ((NTSTATUS) 0xC00000ECL)
-#endif
-
-#ifndef STATUS_NOT_LOGON_PROCESS
-# define STATUS_NOT_LOGON_PROCESS ((NTSTATUS) 0xC00000EDL)
-#endif
-
-#ifndef STATUS_LOGON_SESSION_EXISTS
-# define STATUS_LOGON_SESSION_EXISTS ((NTSTATUS) 0xC00000EEL)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_1
-# define STATUS_INVALID_PARAMETER_1 ((NTSTATUS) 0xC00000EFL)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_2
-# define STATUS_INVALID_PARAMETER_2 ((NTSTATUS) 0xC00000F0L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_3
-# define STATUS_INVALID_PARAMETER_3 ((NTSTATUS) 0xC00000F1L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_4
-# define STATUS_INVALID_PARAMETER_4 ((NTSTATUS) 0xC00000F2L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_5
-# define STATUS_INVALID_PARAMETER_5 ((NTSTATUS) 0xC00000F3L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_6
-# define STATUS_INVALID_PARAMETER_6 ((NTSTATUS) 0xC00000F4L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_7
-# define STATUS_INVALID_PARAMETER_7 ((NTSTATUS) 0xC00000F5L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_8
-# define STATUS_INVALID_PARAMETER_8 ((NTSTATUS) 0xC00000F6L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_9
-# define STATUS_INVALID_PARAMETER_9 ((NTSTATUS) 0xC00000F7L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_10
-# define STATUS_INVALID_PARAMETER_10 ((NTSTATUS) 0xC00000F8L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_11
-# define STATUS_INVALID_PARAMETER_11 ((NTSTATUS) 0xC00000F9L)
-#endif
-
-#ifndef STATUS_INVALID_PARAMETER_12
-# define STATUS_INVALID_PARAMETER_12 ((NTSTATUS) 0xC00000FAL)
-#endif
-
-#ifndef STATUS_REDIRECTOR_NOT_STARTED
-# define STATUS_REDIRECTOR_NOT_STARTED ((NTSTATUS) 0xC00000FBL)
-#endif
-
-#ifndef STATUS_REDIRECTOR_STARTED
-# define STATUS_REDIRECTOR_STARTED ((NTSTATUS) 0xC00000FCL)
-#endif
-
-#ifndef STATUS_STACK_OVERFLOW
-# define STATUS_STACK_OVERFLOW ((NTSTATUS) 0xC00000FDL)
-#endif
-
-#ifndef STATUS_NO_SUCH_PACKAGE
-# define STATUS_NO_SUCH_PACKAGE ((NTSTATUS) 0xC00000FEL)
-#endif
-
-#ifndef STATUS_BAD_FUNCTION_TABLE
-# define STATUS_BAD_FUNCTION_TABLE ((NTSTATUS) 0xC00000FFL)
-#endif
-
-#ifndef STATUS_VARIABLE_NOT_FOUND
-# define STATUS_VARIABLE_NOT_FOUND ((NTSTATUS) 0xC0000100L)
-#endif
-
-#ifndef STATUS_DIRECTORY_NOT_EMPTY
-# define STATUS_DIRECTORY_NOT_EMPTY ((NTSTATUS) 0xC0000101L)
-#endif
-
-#ifndef STATUS_FILE_CORRUPT_ERROR
-# define STATUS_FILE_CORRUPT_ERROR ((NTSTATUS) 0xC0000102L)
-#endif
-
-#ifndef STATUS_NOT_A_DIRECTORY
-# define STATUS_NOT_A_DIRECTORY ((NTSTATUS) 0xC0000103L)
-#endif
-
-#ifndef STATUS_BAD_LOGON_SESSION_STATE
-# define STATUS_BAD_LOGON_SESSION_STATE ((NTSTATUS) 0xC0000104L)
-#endif
-
-#ifndef STATUS_LOGON_SESSION_COLLISION
-# define STATUS_LOGON_SESSION_COLLISION ((NTSTATUS) 0xC0000105L)
-#endif
-
-#ifndef STATUS_NAME_TOO_LONG
-# define STATUS_NAME_TOO_LONG ((NTSTATUS) 0xC0000106L)
-#endif
-
-#ifndef STATUS_FILES_OPEN
-# define STATUS_FILES_OPEN ((NTSTATUS) 0xC0000107L)
-#endif
-
-#ifndef STATUS_CONNECTION_IN_USE
-# define STATUS_CONNECTION_IN_USE ((NTSTATUS) 0xC0000108L)
-#endif
-
-#ifndef STATUS_MESSAGE_NOT_FOUND
-# define STATUS_MESSAGE_NOT_FOUND ((NTSTATUS) 0xC0000109L)
-#endif
-
-#ifndef STATUS_PROCESS_IS_TERMINATING
-# define STATUS_PROCESS_IS_TERMINATING ((NTSTATUS) 0xC000010AL)
-#endif
-
-#ifndef STATUS_INVALID_LOGON_TYPE
-# define STATUS_INVALID_LOGON_TYPE ((NTSTATUS) 0xC000010BL)
-#endif
-
-#ifndef STATUS_NO_GUID_TRANSLATION
-# define STATUS_NO_GUID_TRANSLATION ((NTSTATUS) 0xC000010CL)
-#endif
-
-#ifndef STATUS_CANNOT_IMPERSONATE
-# define STATUS_CANNOT_IMPERSONATE ((NTSTATUS) 0xC000010DL)
-#endif
-
-#ifndef STATUS_IMAGE_ALREADY_LOADED
-# define STATUS_IMAGE_ALREADY_LOADED ((NTSTATUS) 0xC000010EL)
-#endif
-
-#ifndef STATUS_ABIOS_NOT_PRESENT
-# define STATUS_ABIOS_NOT_PRESENT ((NTSTATUS) 0xC000010FL)
-#endif
-
-#ifndef STATUS_ABIOS_LID_NOT_EXIST
-# define STATUS_ABIOS_LID_NOT_EXIST ((NTSTATUS) 0xC0000110L)
-#endif
-
-#ifndef STATUS_ABIOS_LID_ALREADY_OWNED
-# define STATUS_ABIOS_LID_ALREADY_OWNED ((NTSTATUS) 0xC0000111L)
-#endif
-
-#ifndef STATUS_ABIOS_NOT_LID_OWNER
-# define STATUS_ABIOS_NOT_LID_OWNER ((NTSTATUS) 0xC0000112L)
-#endif
-
-#ifndef STATUS_ABIOS_INVALID_COMMAND
-# define STATUS_ABIOS_INVALID_COMMAND ((NTSTATUS) 0xC0000113L)
-#endif
-
-#ifndef STATUS_ABIOS_INVALID_LID
-# define STATUS_ABIOS_INVALID_LID ((NTSTATUS) 0xC0000114L)
-#endif
-
-#ifndef STATUS_ABIOS_SELECTOR_NOT_AVAILABLE
-# define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE ((NTSTATUS) 0xC0000115L)
-#endif
-
-#ifndef STATUS_ABIOS_INVALID_SELECTOR
-# define STATUS_ABIOS_INVALID_SELECTOR ((NTSTATUS) 0xC0000116L)
-#endif
-
-#ifndef STATUS_NO_LDT
-# define STATUS_NO_LDT ((NTSTATUS) 0xC0000117L)
-#endif
-
-#ifndef STATUS_INVALID_LDT_SIZE
-# define STATUS_INVALID_LDT_SIZE ((NTSTATUS) 0xC0000118L)
-#endif
-
-#ifndef STATUS_INVALID_LDT_OFFSET
-# define STATUS_INVALID_LDT_OFFSET ((NTSTATUS) 0xC0000119L)
-#endif
-
-#ifndef STATUS_INVALID_LDT_DESCRIPTOR
-# define STATUS_INVALID_LDT_DESCRIPTOR ((NTSTATUS) 0xC000011AL)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_NE_FORMAT
-# define STATUS_INVALID_IMAGE_NE_FORMAT ((NTSTATUS) 0xC000011BL)
-#endif
-
-#ifndef STATUS_RXACT_INVALID_STATE
-# define STATUS_RXACT_INVALID_STATE ((NTSTATUS) 0xC000011CL)
-#endif
-
-#ifndef STATUS_RXACT_COMMIT_FAILURE
-# define STATUS_RXACT_COMMIT_FAILURE ((NTSTATUS) 0xC000011DL)
-#endif
-
-#ifndef STATUS_MAPPED_FILE_SIZE_ZERO
-# define STATUS_MAPPED_FILE_SIZE_ZERO ((NTSTATUS) 0xC000011EL)
-#endif
-
-#ifndef STATUS_TOO_MANY_OPENED_FILES
-# define STATUS_TOO_MANY_OPENED_FILES ((NTSTATUS) 0xC000011FL)
-#endif
-
-#ifndef STATUS_CANCELLED
-# define STATUS_CANCELLED ((NTSTATUS) 0xC0000120L)
-#endif
-
-#ifndef STATUS_CANNOT_DELETE
-# define STATUS_CANNOT_DELETE ((NTSTATUS) 0xC0000121L)
-#endif
-
-#ifndef STATUS_INVALID_COMPUTER_NAME
-# define STATUS_INVALID_COMPUTER_NAME ((NTSTATUS) 0xC0000122L)
-#endif
-
-#ifndef STATUS_FILE_DELETED
-# define STATUS_FILE_DELETED ((NTSTATUS) 0xC0000123L)
-#endif
-
-#ifndef STATUS_SPECIAL_ACCOUNT
-# define STATUS_SPECIAL_ACCOUNT ((NTSTATUS) 0xC0000124L)
-#endif
-
-#ifndef STATUS_SPECIAL_GROUP
-# define STATUS_SPECIAL_GROUP ((NTSTATUS) 0xC0000125L)
-#endif
-
-#ifndef STATUS_SPECIAL_USER
-# define STATUS_SPECIAL_USER ((NTSTATUS) 0xC0000126L)
-#endif
-
-#ifndef STATUS_MEMBERS_PRIMARY_GROUP
-# define STATUS_MEMBERS_PRIMARY_GROUP ((NTSTATUS) 0xC0000127L)
-#endif
-
-#ifndef STATUS_FILE_CLOSED
-# define STATUS_FILE_CLOSED ((NTSTATUS) 0xC0000128L)
-#endif
-
-#ifndef STATUS_TOO_MANY_THREADS
-# define STATUS_TOO_MANY_THREADS ((NTSTATUS) 0xC0000129L)
-#endif
-
-#ifndef STATUS_THREAD_NOT_IN_PROCESS
-# define STATUS_THREAD_NOT_IN_PROCESS ((NTSTATUS) 0xC000012AL)
-#endif
-
-#ifndef STATUS_TOKEN_ALREADY_IN_USE
-# define STATUS_TOKEN_ALREADY_IN_USE ((NTSTATUS) 0xC000012BL)
-#endif
-
-#ifndef STATUS_PAGEFILE_QUOTA_EXCEEDED
-# define STATUS_PAGEFILE_QUOTA_EXCEEDED ((NTSTATUS) 0xC000012CL)
-#endif
-
-#ifndef STATUS_COMMITMENT_LIMIT
-# define STATUS_COMMITMENT_LIMIT ((NTSTATUS) 0xC000012DL)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_LE_FORMAT
-# define STATUS_INVALID_IMAGE_LE_FORMAT ((NTSTATUS) 0xC000012EL)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_NOT_MZ
-# define STATUS_INVALID_IMAGE_NOT_MZ ((NTSTATUS) 0xC000012FL)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_PROTECT
-# define STATUS_INVALID_IMAGE_PROTECT ((NTSTATUS) 0xC0000130L)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_WIN_16
-# define STATUS_INVALID_IMAGE_WIN_16 ((NTSTATUS) 0xC0000131L)
-#endif
-
-#ifndef STATUS_LOGON_SERVER_CONFLICT
-# define STATUS_LOGON_SERVER_CONFLICT ((NTSTATUS) 0xC0000132L)
-#endif
-
-#ifndef STATUS_TIME_DIFFERENCE_AT_DC
-# define STATUS_TIME_DIFFERENCE_AT_DC ((NTSTATUS) 0xC0000133L)
-#endif
-
-#ifndef STATUS_SYNCHRONIZATION_REQUIRED
-# define STATUS_SYNCHRONIZATION_REQUIRED ((NTSTATUS) 0xC0000134L)
-#endif
-
-#ifndef STATUS_DLL_NOT_FOUND
-# define STATUS_DLL_NOT_FOUND ((NTSTATUS) 0xC0000135L)
-#endif
-
-#ifndef STATUS_OPEN_FAILED
-# define STATUS_OPEN_FAILED ((NTSTATUS) 0xC0000136L)
-#endif
-
-#ifndef STATUS_IO_PRIVILEGE_FAILED
-# define STATUS_IO_PRIVILEGE_FAILED ((NTSTATUS) 0xC0000137L)
-#endif
-
-#ifndef STATUS_ORDINAL_NOT_FOUND
-# define STATUS_ORDINAL_NOT_FOUND ((NTSTATUS) 0xC0000138L)
-#endif
-
-#ifndef STATUS_ENTRYPOINT_NOT_FOUND
-# define STATUS_ENTRYPOINT_NOT_FOUND ((NTSTATUS) 0xC0000139L)
-#endif
-
-#ifndef STATUS_CONTROL_C_EXIT
-# define STATUS_CONTROL_C_EXIT ((NTSTATUS) 0xC000013AL)
-#endif
-
-#ifndef STATUS_LOCAL_DISCONNECT
-# define STATUS_LOCAL_DISCONNECT ((NTSTATUS) 0xC000013BL)
-#endif
-
-#ifndef STATUS_REMOTE_DISCONNECT
-# define STATUS_REMOTE_DISCONNECT ((NTSTATUS) 0xC000013CL)
-#endif
-
-#ifndef STATUS_REMOTE_RESOURCES
-# define STATUS_REMOTE_RESOURCES ((NTSTATUS) 0xC000013DL)
-#endif
-
-#ifndef STATUS_LINK_FAILED
-# define STATUS_LINK_FAILED ((NTSTATUS) 0xC000013EL)
-#endif
-
-#ifndef STATUS_LINK_TIMEOUT
-# define STATUS_LINK_TIMEOUT ((NTSTATUS) 0xC000013FL)
-#endif
-
-#ifndef STATUS_INVALID_CONNECTION
-# define STATUS_INVALID_CONNECTION ((NTSTATUS) 0xC0000140L)
-#endif
-
-#ifndef STATUS_INVALID_ADDRESS
-# define STATUS_INVALID_ADDRESS ((NTSTATUS) 0xC0000141L)
-#endif
-
-#ifndef STATUS_DLL_INIT_FAILED
-# define STATUS_DLL_INIT_FAILED ((NTSTATUS) 0xC0000142L)
-#endif
-
-#ifndef STATUS_MISSING_SYSTEMFILE
-# define STATUS_MISSING_SYSTEMFILE ((NTSTATUS) 0xC0000143L)
-#endif
-
-#ifndef STATUS_UNHANDLED_EXCEPTION
-# define STATUS_UNHANDLED_EXCEPTION ((NTSTATUS) 0xC0000144L)
-#endif
-
-#ifndef STATUS_APP_INIT_FAILURE
-# define STATUS_APP_INIT_FAILURE ((NTSTATUS) 0xC0000145L)
-#endif
-
-#ifndef STATUS_PAGEFILE_CREATE_FAILED
-# define STATUS_PAGEFILE_CREATE_FAILED ((NTSTATUS) 0xC0000146L)
-#endif
-
-#ifndef STATUS_NO_PAGEFILE
-# define STATUS_NO_PAGEFILE ((NTSTATUS) 0xC0000147L)
-#endif
-
-#ifndef STATUS_INVALID_LEVEL
-# define STATUS_INVALID_LEVEL ((NTSTATUS) 0xC0000148L)
-#endif
-
-#ifndef STATUS_WRONG_PASSWORD_CORE
-# define STATUS_WRONG_PASSWORD_CORE ((NTSTATUS) 0xC0000149L)
-#endif
-
-#ifndef STATUS_ILLEGAL_FLOAT_CONTEXT
-# define STATUS_ILLEGAL_FLOAT_CONTEXT ((NTSTATUS) 0xC000014AL)
-#endif
-
-#ifndef STATUS_PIPE_BROKEN
-# define STATUS_PIPE_BROKEN ((NTSTATUS) 0xC000014BL)
-#endif
-
-#ifndef STATUS_REGISTRY_CORRUPT
-# define STATUS_REGISTRY_CORRUPT ((NTSTATUS) 0xC000014CL)
-#endif
-
-#ifndef STATUS_REGISTRY_IO_FAILED
-# define STATUS_REGISTRY_IO_FAILED ((NTSTATUS) 0xC000014DL)
-#endif
-
-#ifndef STATUS_NO_EVENT_PAIR
-# define STATUS_NO_EVENT_PAIR ((NTSTATUS) 0xC000014EL)
-#endif
-
-#ifndef STATUS_UNRECOGNIZED_VOLUME
-# define STATUS_UNRECOGNIZED_VOLUME ((NTSTATUS) 0xC000014FL)
-#endif
-
-#ifndef STATUS_SERIAL_NO_DEVICE_INITED
-# define STATUS_SERIAL_NO_DEVICE_INITED ((NTSTATUS) 0xC0000150L)
-#endif
-
-#ifndef STATUS_NO_SUCH_ALIAS
-# define STATUS_NO_SUCH_ALIAS ((NTSTATUS) 0xC0000151L)
-#endif
-
-#ifndef STATUS_MEMBER_NOT_IN_ALIAS
-# define STATUS_MEMBER_NOT_IN_ALIAS ((NTSTATUS) 0xC0000152L)
-#endif
-
-#ifndef STATUS_MEMBER_IN_ALIAS
-# define STATUS_MEMBER_IN_ALIAS ((NTSTATUS) 0xC0000153L)
-#endif
-
-#ifndef STATUS_ALIAS_EXISTS
-# define STATUS_ALIAS_EXISTS ((NTSTATUS) 0xC0000154L)
-#endif
-
-#ifndef STATUS_LOGON_NOT_GRANTED
-# define STATUS_LOGON_NOT_GRANTED ((NTSTATUS) 0xC0000155L)
-#endif
-
-#ifndef STATUS_TOO_MANY_SECRETS
-# define STATUS_TOO_MANY_SECRETS ((NTSTATUS) 0xC0000156L)
-#endif
-
-#ifndef STATUS_SECRET_TOO_LONG
-# define STATUS_SECRET_TOO_LONG ((NTSTATUS) 0xC0000157L)
-#endif
-
-#ifndef STATUS_INTERNAL_DB_ERROR
-# define STATUS_INTERNAL_DB_ERROR ((NTSTATUS) 0xC0000158L)
-#endif
-
-#ifndef STATUS_FULLSCREEN_MODE
-# define STATUS_FULLSCREEN_MODE ((NTSTATUS) 0xC0000159L)
-#endif
-
-#ifndef STATUS_TOO_MANY_CONTEXT_IDS
-# define STATUS_TOO_MANY_CONTEXT_IDS ((NTSTATUS) 0xC000015AL)
-#endif
-
-#ifndef STATUS_LOGON_TYPE_NOT_GRANTED
-# define STATUS_LOGON_TYPE_NOT_GRANTED ((NTSTATUS) 0xC000015BL)
-#endif
-
-#ifndef STATUS_NOT_REGISTRY_FILE
-# define STATUS_NOT_REGISTRY_FILE ((NTSTATUS) 0xC000015CL)
-#endif
-
-#ifndef STATUS_NT_CROSS_ENCRYPTION_REQUIRED
-# define STATUS_NT_CROSS_ENCRYPTION_REQUIRED ((NTSTATUS) 0xC000015DL)
-#endif
-
-#ifndef STATUS_DOMAIN_CTRLR_CONFIG_ERROR
-# define STATUS_DOMAIN_CTRLR_CONFIG_ERROR ((NTSTATUS) 0xC000015EL)
-#endif
-
-#ifndef STATUS_FT_MISSING_MEMBER
-# define STATUS_FT_MISSING_MEMBER ((NTSTATUS) 0xC000015FL)
-#endif
-
-#ifndef STATUS_ILL_FORMED_SERVICE_ENTRY
-# define STATUS_ILL_FORMED_SERVICE_ENTRY ((NTSTATUS) 0xC0000160L)
-#endif
-
-#ifndef STATUS_ILLEGAL_CHARACTER
-# define STATUS_ILLEGAL_CHARACTER ((NTSTATUS) 0xC0000161L)
-#endif
-
-#ifndef STATUS_UNMAPPABLE_CHARACTER
-# define STATUS_UNMAPPABLE_CHARACTER ((NTSTATUS) 0xC0000162L)
-#endif
-
-#ifndef STATUS_UNDEFINED_CHARACTER
-# define STATUS_UNDEFINED_CHARACTER ((NTSTATUS) 0xC0000163L)
-#endif
-
-#ifndef STATUS_FLOPPY_VOLUME
-# define STATUS_FLOPPY_VOLUME ((NTSTATUS) 0xC0000164L)
-#endif
-
-#ifndef STATUS_FLOPPY_ID_MARK_NOT_FOUND
-# define STATUS_FLOPPY_ID_MARK_NOT_FOUND ((NTSTATUS) 0xC0000165L)
-#endif
-
-#ifndef STATUS_FLOPPY_WRONG_CYLINDER
-# define STATUS_FLOPPY_WRONG_CYLINDER ((NTSTATUS) 0xC0000166L)
-#endif
-
-#ifndef STATUS_FLOPPY_UNKNOWN_ERROR
-# define STATUS_FLOPPY_UNKNOWN_ERROR ((NTSTATUS) 0xC0000167L)
-#endif
-
-#ifndef STATUS_FLOPPY_BAD_REGISTERS
-# define STATUS_FLOPPY_BAD_REGISTERS ((NTSTATUS) 0xC0000168L)
-#endif
-
-#ifndef STATUS_DISK_RECALIBRATE_FAILED
-# define STATUS_DISK_RECALIBRATE_FAILED ((NTSTATUS) 0xC0000169L)
-#endif
-
-#ifndef STATUS_DISK_OPERATION_FAILED
-# define STATUS_DISK_OPERATION_FAILED ((NTSTATUS) 0xC000016AL)
-#endif
-
-#ifndef STATUS_DISK_RESET_FAILED
-# define STATUS_DISK_RESET_FAILED ((NTSTATUS) 0xC000016BL)
-#endif
-
-#ifndef STATUS_SHARED_IRQ_BUSY
-# define STATUS_SHARED_IRQ_BUSY ((NTSTATUS) 0xC000016CL)
-#endif
-
-#ifndef STATUS_FT_ORPHANING
-# define STATUS_FT_ORPHANING ((NTSTATUS) 0xC000016DL)
-#endif
-
-#ifndef STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT
-# define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT ((NTSTATUS) 0xC000016EL)
-#endif
-
-#ifndef STATUS_PARTITION_FAILURE
-# define STATUS_PARTITION_FAILURE ((NTSTATUS) 0xC0000172L)
-#endif
-
-#ifndef STATUS_INVALID_BLOCK_LENGTH
-# define STATUS_INVALID_BLOCK_LENGTH ((NTSTATUS) 0xC0000173L)
-#endif
-
-#ifndef STATUS_DEVICE_NOT_PARTITIONED
-# define STATUS_DEVICE_NOT_PARTITIONED ((NTSTATUS) 0xC0000174L)
-#endif
-
-#ifndef STATUS_UNABLE_TO_LOCK_MEDIA
-# define STATUS_UNABLE_TO_LOCK_MEDIA ((NTSTATUS) 0xC0000175L)
-#endif
-
-#ifndef STATUS_UNABLE_TO_UNLOAD_MEDIA
-# define STATUS_UNABLE_TO_UNLOAD_MEDIA ((NTSTATUS) 0xC0000176L)
-#endif
-
-#ifndef STATUS_EOM_OVERFLOW
-# define STATUS_EOM_OVERFLOW ((NTSTATUS) 0xC0000177L)
-#endif
-
-#ifndef STATUS_NO_MEDIA
-# define STATUS_NO_MEDIA ((NTSTATUS) 0xC0000178L)
-#endif
-
-#ifndef STATUS_NO_SUCH_MEMBER
-# define STATUS_NO_SUCH_MEMBER ((NTSTATUS) 0xC000017AL)
-#endif
-
-#ifndef STATUS_INVALID_MEMBER
-# define STATUS_INVALID_MEMBER ((NTSTATUS) 0xC000017BL)
-#endif
-
-#ifndef STATUS_KEY_DELETED
-# define STATUS_KEY_DELETED ((NTSTATUS) 0xC000017CL)
-#endif
-
-#ifndef STATUS_NO_LOG_SPACE
-# define STATUS_NO_LOG_SPACE ((NTSTATUS) 0xC000017DL)
-#endif
-
-#ifndef STATUS_TOO_MANY_SIDS
-# define STATUS_TOO_MANY_SIDS ((NTSTATUS) 0xC000017EL)
-#endif
-
-#ifndef STATUS_LM_CROSS_ENCRYPTION_REQUIRED
-# define STATUS_LM_CROSS_ENCRYPTION_REQUIRED ((NTSTATUS) 0xC000017FL)
-#endif
-
-#ifndef STATUS_KEY_HAS_CHILDREN
-# define STATUS_KEY_HAS_CHILDREN ((NTSTATUS) 0xC0000180L)
-#endif
-
-#ifndef STATUS_CHILD_MUST_BE_VOLATILE
-# define STATUS_CHILD_MUST_BE_VOLATILE ((NTSTATUS) 0xC0000181L)
-#endif
-
-#ifndef STATUS_DEVICE_CONFIGURATION_ERROR
-# define STATUS_DEVICE_CONFIGURATION_ERROR ((NTSTATUS) 0xC0000182L)
-#endif
-
-#ifndef STATUS_DRIVER_INTERNAL_ERROR
-# define STATUS_DRIVER_INTERNAL_ERROR ((NTSTATUS) 0xC0000183L)
-#endif
-
-#ifndef STATUS_INVALID_DEVICE_STATE
-# define STATUS_INVALID_DEVICE_STATE ((NTSTATUS) 0xC0000184L)
-#endif
-
-#ifndef STATUS_IO_DEVICE_ERROR
-# define STATUS_IO_DEVICE_ERROR ((NTSTATUS) 0xC0000185L)
-#endif
-
-#ifndef STATUS_DEVICE_PROTOCOL_ERROR
-# define STATUS_DEVICE_PROTOCOL_ERROR ((NTSTATUS) 0xC0000186L)
-#endif
-
-#ifndef STATUS_BACKUP_CONTROLLER
-# define STATUS_BACKUP_CONTROLLER ((NTSTATUS) 0xC0000187L)
-#endif
-
-#ifndef STATUS_LOG_FILE_FULL
-# define STATUS_LOG_FILE_FULL ((NTSTATUS) 0xC0000188L)
-#endif
-
-#ifndef STATUS_TOO_LATE
-# define STATUS_TOO_LATE ((NTSTATUS) 0xC0000189L)
-#endif
-
-#ifndef STATUS_NO_TRUST_LSA_SECRET
-# define STATUS_NO_TRUST_LSA_SECRET ((NTSTATUS) 0xC000018AL)
-#endif
-
-#ifndef STATUS_NO_TRUST_SAM_ACCOUNT
-# define STATUS_NO_TRUST_SAM_ACCOUNT ((NTSTATUS) 0xC000018BL)
-#endif
-
-#ifndef STATUS_TRUSTED_DOMAIN_FAILURE
-# define STATUS_TRUSTED_DOMAIN_FAILURE ((NTSTATUS) 0xC000018CL)
-#endif
-
-#ifndef STATUS_TRUSTED_RELATIONSHIP_FAILURE
-# define STATUS_TRUSTED_RELATIONSHIP_FAILURE ((NTSTATUS) 0xC000018DL)
-#endif
-
-#ifndef STATUS_EVENTLOG_FILE_CORRUPT
-# define STATUS_EVENTLOG_FILE_CORRUPT ((NTSTATUS) 0xC000018EL)
-#endif
-
-#ifndef STATUS_EVENTLOG_CANT_START
-# define STATUS_EVENTLOG_CANT_START ((NTSTATUS) 0xC000018FL)
-#endif
-
-#ifndef STATUS_TRUST_FAILURE
-# define STATUS_TRUST_FAILURE ((NTSTATUS) 0xC0000190L)
-#endif
-
-#ifndef STATUS_MUTANT_LIMIT_EXCEEDED
-# define STATUS_MUTANT_LIMIT_EXCEEDED ((NTSTATUS) 0xC0000191L)
-#endif
-
-#ifndef STATUS_NETLOGON_NOT_STARTED
-# define STATUS_NETLOGON_NOT_STARTED ((NTSTATUS) 0xC0000192L)
-#endif
-
-#ifndef STATUS_ACCOUNT_EXPIRED
-# define STATUS_ACCOUNT_EXPIRED ((NTSTATUS) 0xC0000193L)
-#endif
-
-#ifndef STATUS_POSSIBLE_DEADLOCK
-# define STATUS_POSSIBLE_DEADLOCK ((NTSTATUS) 0xC0000194L)
-#endif
-
-#ifndef STATUS_NETWORK_CREDENTIAL_CONFLICT
-# define STATUS_NETWORK_CREDENTIAL_CONFLICT ((NTSTATUS) 0xC0000195L)
-#endif
-
-#ifndef STATUS_REMOTE_SESSION_LIMIT
-# define STATUS_REMOTE_SESSION_LIMIT ((NTSTATUS) 0xC0000196L)
-#endif
-
-#ifndef STATUS_EVENTLOG_FILE_CHANGED
-# define STATUS_EVENTLOG_FILE_CHANGED ((NTSTATUS) 0xC0000197L)
-#endif
-
-#ifndef STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT
-# define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT ((NTSTATUS) 0xC0000198L)
-#endif
-
-#ifndef STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT
-# define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT ((NTSTATUS) 0xC0000199L)
-#endif
-
-#ifndef STATUS_NOLOGON_SERVER_TRUST_ACCOUNT
-# define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT ((NTSTATUS) 0xC000019AL)
-#endif
-
-#ifndef STATUS_DOMAIN_TRUST_INCONSISTENT
-# define STATUS_DOMAIN_TRUST_INCONSISTENT ((NTSTATUS) 0xC000019BL)
-#endif
-
-#ifndef STATUS_FS_DRIVER_REQUIRED
-# define STATUS_FS_DRIVER_REQUIRED ((NTSTATUS) 0xC000019CL)
-#endif
-
-#ifndef STATUS_IMAGE_ALREADY_LOADED_AS_DLL
-# define STATUS_IMAGE_ALREADY_LOADED_AS_DLL ((NTSTATUS) 0xC000019DL)
-#endif
-
-#ifndef STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING
-# define STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING ((NTSTATUS) 0xC000019EL)
-#endif
-
-#ifndef STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME
-# define STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME ((NTSTATUS) 0xC000019FL)
-#endif
-
-#ifndef STATUS_SECURITY_STREAM_IS_INCONSISTENT
-# define STATUS_SECURITY_STREAM_IS_INCONSISTENT ((NTSTATUS) 0xC00001A0L)
-#endif
-
-#ifndef STATUS_INVALID_LOCK_RANGE
-# define STATUS_INVALID_LOCK_RANGE ((NTSTATUS) 0xC00001A1L)
-#endif
-
-#ifndef STATUS_INVALID_ACE_CONDITION
-# define STATUS_INVALID_ACE_CONDITION ((NTSTATUS) 0xC00001A2L)
-#endif
-
-#ifndef STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT
-# define STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT ((NTSTATUS) 0xC00001A3L)
-#endif
-
-#ifndef STATUS_NOTIFICATION_GUID_ALREADY_DEFINED
-# define STATUS_NOTIFICATION_GUID_ALREADY_DEFINED ((NTSTATUS) 0xC00001A4L)
-#endif
-
-#ifndef STATUS_NETWORK_OPEN_RESTRICTION
-# define STATUS_NETWORK_OPEN_RESTRICTION ((NTSTATUS) 0xC0000201L)
-#endif
-
-#ifndef STATUS_NO_USER_SESSION_KEY
-# define STATUS_NO_USER_SESSION_KEY ((NTSTATUS) 0xC0000202L)
-#endif
-
-#ifndef STATUS_USER_SESSION_DELETED
-# define STATUS_USER_SESSION_DELETED ((NTSTATUS) 0xC0000203L)
-#endif
-
-#ifndef STATUS_RESOURCE_LANG_NOT_FOUND
-# define STATUS_RESOURCE_LANG_NOT_FOUND ((NTSTATUS) 0xC0000204L)
-#endif
-
-#ifndef STATUS_INSUFF_SERVER_RESOURCES
-# define STATUS_INSUFF_SERVER_RESOURCES ((NTSTATUS) 0xC0000205L)
-#endif
-
-#ifndef STATUS_INVALID_BUFFER_SIZE
-# define STATUS_INVALID_BUFFER_SIZE ((NTSTATUS) 0xC0000206L)
-#endif
-
-#ifndef STATUS_INVALID_ADDRESS_COMPONENT
-# define STATUS_INVALID_ADDRESS_COMPONENT ((NTSTATUS) 0xC0000207L)
-#endif
-
-#ifndef STATUS_INVALID_ADDRESS_WILDCARD
-# define STATUS_INVALID_ADDRESS_WILDCARD ((NTSTATUS) 0xC0000208L)
-#endif
-
-#ifndef STATUS_TOO_MANY_ADDRESSES
-# define STATUS_TOO_MANY_ADDRESSES ((NTSTATUS) 0xC0000209L)
-#endif
-
-#ifndef STATUS_ADDRESS_ALREADY_EXISTS
-# define STATUS_ADDRESS_ALREADY_EXISTS ((NTSTATUS) 0xC000020AL)
-#endif
-
-#ifndef STATUS_ADDRESS_CLOSED
-# define STATUS_ADDRESS_CLOSED ((NTSTATUS) 0xC000020BL)
-#endif
-
-#ifndef STATUS_CONNECTION_DISCONNECTED
-# define STATUS_CONNECTION_DISCONNECTED ((NTSTATUS) 0xC000020CL)
-#endif
-
-#ifndef STATUS_CONNECTION_RESET
-# define STATUS_CONNECTION_RESET ((NTSTATUS) 0xC000020DL)
-#endif
-
-#ifndef STATUS_TOO_MANY_NODES
-# define STATUS_TOO_MANY_NODES ((NTSTATUS) 0xC000020EL)
-#endif
-
-#ifndef STATUS_TRANSACTION_ABORTED
-# define STATUS_TRANSACTION_ABORTED ((NTSTATUS) 0xC000020FL)
-#endif
-
-#ifndef STATUS_TRANSACTION_TIMED_OUT
-# define STATUS_TRANSACTION_TIMED_OUT ((NTSTATUS) 0xC0000210L)
-#endif
-
-#ifndef STATUS_TRANSACTION_NO_RELEASE
-# define STATUS_TRANSACTION_NO_RELEASE ((NTSTATUS) 0xC0000211L)
-#endif
-
-#ifndef STATUS_TRANSACTION_NO_MATCH
-# define STATUS_TRANSACTION_NO_MATCH ((NTSTATUS) 0xC0000212L)
-#endif
-
-#ifndef STATUS_TRANSACTION_RESPONDED
-# define STATUS_TRANSACTION_RESPONDED ((NTSTATUS) 0xC0000213L)
-#endif
-
-#ifndef STATUS_TRANSACTION_INVALID_ID
-# define STATUS_TRANSACTION_INVALID_ID ((NTSTATUS) 0xC0000214L)
-#endif
-
-#ifndef STATUS_TRANSACTION_INVALID_TYPE
-# define STATUS_TRANSACTION_INVALID_TYPE ((NTSTATUS) 0xC0000215L)
-#endif
-
-#ifndef STATUS_NOT_SERVER_SESSION
-# define STATUS_NOT_SERVER_SESSION ((NTSTATUS) 0xC0000216L)
-#endif
-
-#ifndef STATUS_NOT_CLIENT_SESSION
-# define STATUS_NOT_CLIENT_SESSION ((NTSTATUS) 0xC0000217L)
-#endif
-
-#ifndef STATUS_CANNOT_LOAD_REGISTRY_FILE
-# define STATUS_CANNOT_LOAD_REGISTRY_FILE ((NTSTATUS) 0xC0000218L)
-#endif
-
-#ifndef STATUS_DEBUG_ATTACH_FAILED
-# define STATUS_DEBUG_ATTACH_FAILED ((NTSTATUS) 0xC0000219L)
-#endif
-
-#ifndef STATUS_SYSTEM_PROCESS_TERMINATED
-# define STATUS_SYSTEM_PROCESS_TERMINATED ((NTSTATUS) 0xC000021AL)
-#endif
-
-#ifndef STATUS_DATA_NOT_ACCEPTED
-# define STATUS_DATA_NOT_ACCEPTED ((NTSTATUS) 0xC000021BL)
-#endif
-
-#ifndef STATUS_NO_BROWSER_SERVERS_FOUND
-# define STATUS_NO_BROWSER_SERVERS_FOUND ((NTSTATUS) 0xC000021CL)
-#endif
-
-#ifndef STATUS_VDM_HARD_ERROR
-# define STATUS_VDM_HARD_ERROR ((NTSTATUS) 0xC000021DL)
-#endif
-
-#ifndef STATUS_DRIVER_CANCEL_TIMEOUT
-# define STATUS_DRIVER_CANCEL_TIMEOUT ((NTSTATUS) 0xC000021EL)
-#endif
-
-#ifndef STATUS_REPLY_MESSAGE_MISMATCH
-# define STATUS_REPLY_MESSAGE_MISMATCH ((NTSTATUS) 0xC000021FL)
-#endif
-
-#ifndef STATUS_MAPPED_ALIGNMENT
-# define STATUS_MAPPED_ALIGNMENT ((NTSTATUS) 0xC0000220L)
-#endif
-
-#ifndef STATUS_IMAGE_CHECKSUM_MISMATCH
-# define STATUS_IMAGE_CHECKSUM_MISMATCH ((NTSTATUS) 0xC0000221L)
-#endif
-
-#ifndef STATUS_LOST_WRITEBEHIND_DATA
-# define STATUS_LOST_WRITEBEHIND_DATA ((NTSTATUS) 0xC0000222L)
-#endif
-
-#ifndef STATUS_CLIENT_SERVER_PARAMETERS_INVALID
-# define STATUS_CLIENT_SERVER_PARAMETERS_INVALID ((NTSTATUS) 0xC0000223L)
-#endif
-
-#ifndef STATUS_PASSWORD_MUST_CHANGE
-# define STATUS_PASSWORD_MUST_CHANGE ((NTSTATUS) 0xC0000224L)
-#endif
-
-#ifndef STATUS_NOT_FOUND
-# define STATUS_NOT_FOUND ((NTSTATUS) 0xC0000225L)
-#endif
-
-#ifndef STATUS_NOT_TINY_STREAM
-# define STATUS_NOT_TINY_STREAM ((NTSTATUS) 0xC0000226L)
-#endif
-
-#ifndef STATUS_RECOVERY_FAILURE
-# define STATUS_RECOVERY_FAILURE ((NTSTATUS) 0xC0000227L)
-#endif
-
-#ifndef STATUS_STACK_OVERFLOW_READ
-# define STATUS_STACK_OVERFLOW_READ ((NTSTATUS) 0xC0000228L)
-#endif
-
-#ifndef STATUS_FAIL_CHECK
-# define STATUS_FAIL_CHECK ((NTSTATUS) 0xC0000229L)
-#endif
-
-#ifndef STATUS_DUPLICATE_OBJECTID
-# define STATUS_DUPLICATE_OBJECTID ((NTSTATUS) 0xC000022AL)
-#endif
-
-#ifndef STATUS_OBJECTID_EXISTS
-# define STATUS_OBJECTID_EXISTS ((NTSTATUS) 0xC000022BL)
-#endif
-
-#ifndef STATUS_CONVERT_TO_LARGE
-# define STATUS_CONVERT_TO_LARGE ((NTSTATUS) 0xC000022CL)
-#endif
-
-#ifndef STATUS_RETRY
-# define STATUS_RETRY ((NTSTATUS) 0xC000022DL)
-#endif
-
-#ifndef STATUS_FOUND_OUT_OF_SCOPE
-# define STATUS_FOUND_OUT_OF_SCOPE ((NTSTATUS) 0xC000022EL)
-#endif
-
-#ifndef STATUS_ALLOCATE_BUCKET
-# define STATUS_ALLOCATE_BUCKET ((NTSTATUS) 0xC000022FL)
-#endif
-
-#ifndef STATUS_PROPSET_NOT_FOUND
-# define STATUS_PROPSET_NOT_FOUND ((NTSTATUS) 0xC0000230L)
-#endif
-
-#ifndef STATUS_MARSHALL_OVERFLOW
-# define STATUS_MARSHALL_OVERFLOW ((NTSTATUS) 0xC0000231L)
-#endif
-
-#ifndef STATUS_INVALID_VARIANT
-# define STATUS_INVALID_VARIANT ((NTSTATUS) 0xC0000232L)
-#endif
-
-#ifndef STATUS_DOMAIN_CONTROLLER_NOT_FOUND
-# define STATUS_DOMAIN_CONTROLLER_NOT_FOUND ((NTSTATUS) 0xC0000233L)
-#endif
-
-#ifndef STATUS_ACCOUNT_LOCKED_OUT
-# define STATUS_ACCOUNT_LOCKED_OUT ((NTSTATUS) 0xC0000234L)
-#endif
-
-#ifndef STATUS_HANDLE_NOT_CLOSABLE
-# define STATUS_HANDLE_NOT_CLOSABLE ((NTSTATUS) 0xC0000235L)
-#endif
-
-#ifndef STATUS_CONNECTION_REFUSED
-# define STATUS_CONNECTION_REFUSED ((NTSTATUS) 0xC0000236L)
-#endif
-
-#ifndef STATUS_GRACEFUL_DISCONNECT
-# define STATUS_GRACEFUL_DISCONNECT ((NTSTATUS) 0xC0000237L)
-#endif
-
-#ifndef STATUS_ADDRESS_ALREADY_ASSOCIATED
-# define STATUS_ADDRESS_ALREADY_ASSOCIATED ((NTSTATUS) 0xC0000238L)
-#endif
-
-#ifndef STATUS_ADDRESS_NOT_ASSOCIATED
-# define STATUS_ADDRESS_NOT_ASSOCIATED ((NTSTATUS) 0xC0000239L)
-#endif
-
-#ifndef STATUS_CONNECTION_INVALID
-# define STATUS_CONNECTION_INVALID ((NTSTATUS) 0xC000023AL)
-#endif
-
-#ifndef STATUS_CONNECTION_ACTIVE
-# define STATUS_CONNECTION_ACTIVE ((NTSTATUS) 0xC000023BL)
-#endif
-
-#ifndef STATUS_NETWORK_UNREACHABLE
-# define STATUS_NETWORK_UNREACHABLE ((NTSTATUS) 0xC000023CL)
-#endif
-
-#ifndef STATUS_HOST_UNREACHABLE
-# define STATUS_HOST_UNREACHABLE ((NTSTATUS) 0xC000023DL)
-#endif
-
-#ifndef STATUS_PROTOCOL_UNREACHABLE
-# define STATUS_PROTOCOL_UNREACHABLE ((NTSTATUS) 0xC000023EL)
-#endif
-
-#ifndef STATUS_PORT_UNREACHABLE
-# define STATUS_PORT_UNREACHABLE ((NTSTATUS) 0xC000023FL)
-#endif
-
-#ifndef STATUS_REQUEST_ABORTED
-# define STATUS_REQUEST_ABORTED ((NTSTATUS) 0xC0000240L)
-#endif
-
-#ifndef STATUS_CONNECTION_ABORTED
-# define STATUS_CONNECTION_ABORTED ((NTSTATUS) 0xC0000241L)
-#endif
-
-#ifndef STATUS_BAD_COMPRESSION_BUFFER
-# define STATUS_BAD_COMPRESSION_BUFFER ((NTSTATUS) 0xC0000242L)
-#endif
-
-#ifndef STATUS_USER_MAPPED_FILE
-# define STATUS_USER_MAPPED_FILE ((NTSTATUS) 0xC0000243L)
-#endif
-
-#ifndef STATUS_AUDIT_FAILED
-# define STATUS_AUDIT_FAILED ((NTSTATUS) 0xC0000244L)
-#endif
-
-#ifndef STATUS_TIMER_RESOLUTION_NOT_SET
-# define STATUS_TIMER_RESOLUTION_NOT_SET ((NTSTATUS) 0xC0000245L)
-#endif
-
-#ifndef STATUS_CONNECTION_COUNT_LIMIT
-# define STATUS_CONNECTION_COUNT_LIMIT ((NTSTATUS) 0xC0000246L)
-#endif
-
-#ifndef STATUS_LOGIN_TIME_RESTRICTION
-# define STATUS_LOGIN_TIME_RESTRICTION ((NTSTATUS) 0xC0000247L)
-#endif
-
-#ifndef STATUS_LOGIN_WKSTA_RESTRICTION
-# define STATUS_LOGIN_WKSTA_RESTRICTION ((NTSTATUS) 0xC0000248L)
-#endif
-
-#ifndef STATUS_IMAGE_MP_UP_MISMATCH
-# define STATUS_IMAGE_MP_UP_MISMATCH ((NTSTATUS) 0xC0000249L)
-#endif
-
-#ifndef STATUS_INSUFFICIENT_LOGON_INFO
-# define STATUS_INSUFFICIENT_LOGON_INFO ((NTSTATUS) 0xC0000250L)
-#endif
-
-#ifndef STATUS_BAD_DLL_ENTRYPOINT
-# define STATUS_BAD_DLL_ENTRYPOINT ((NTSTATUS) 0xC0000251L)
-#endif
-
-#ifndef STATUS_BAD_SERVICE_ENTRYPOINT
-# define STATUS_BAD_SERVICE_ENTRYPOINT ((NTSTATUS) 0xC0000252L)
-#endif
-
-#ifndef STATUS_LPC_REPLY_LOST
-# define STATUS_LPC_REPLY_LOST ((NTSTATUS) 0xC0000253L)
-#endif
-
-#ifndef STATUS_IP_ADDRESS_CONFLICT1
-# define STATUS_IP_ADDRESS_CONFLICT1 ((NTSTATUS) 0xC0000254L)
-#endif
-
-#ifndef STATUS_IP_ADDRESS_CONFLICT2
-# define STATUS_IP_ADDRESS_CONFLICT2 ((NTSTATUS) 0xC0000255L)
-#endif
-
-#ifndef STATUS_REGISTRY_QUOTA_LIMIT
-# define STATUS_REGISTRY_QUOTA_LIMIT ((NTSTATUS) 0xC0000256L)
-#endif
-
-#ifndef STATUS_PATH_NOT_COVERED
-# define STATUS_PATH_NOT_COVERED ((NTSTATUS) 0xC0000257L)
-#endif
-
-#ifndef STATUS_NO_CALLBACK_ACTIVE
-# define STATUS_NO_CALLBACK_ACTIVE ((NTSTATUS) 0xC0000258L)
-#endif
-
-#ifndef STATUS_LICENSE_QUOTA_EXCEEDED
-# define STATUS_LICENSE_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000259L)
-#endif
-
-#ifndef STATUS_PWD_TOO_SHORT
-# define STATUS_PWD_TOO_SHORT ((NTSTATUS) 0xC000025AL)
-#endif
-
-#ifndef STATUS_PWD_TOO_RECENT
-# define STATUS_PWD_TOO_RECENT ((NTSTATUS) 0xC000025BL)
-#endif
-
-#ifndef STATUS_PWD_HISTORY_CONFLICT
-# define STATUS_PWD_HISTORY_CONFLICT ((NTSTATUS) 0xC000025CL)
-#endif
-
-#ifndef STATUS_PLUGPLAY_NO_DEVICE
-# define STATUS_PLUGPLAY_NO_DEVICE ((NTSTATUS) 0xC000025EL)
-#endif
-
-#ifndef STATUS_UNSUPPORTED_COMPRESSION
-# define STATUS_UNSUPPORTED_COMPRESSION ((NTSTATUS) 0xC000025FL)
-#endif
-
-#ifndef STATUS_INVALID_HW_PROFILE
-# define STATUS_INVALID_HW_PROFILE ((NTSTATUS) 0xC0000260L)
-#endif
-
-#ifndef STATUS_INVALID_PLUGPLAY_DEVICE_PATH
-# define STATUS_INVALID_PLUGPLAY_DEVICE_PATH ((NTSTATUS) 0xC0000261L)
-#endif
-
-#ifndef STATUS_DRIVER_ORDINAL_NOT_FOUND
-# define STATUS_DRIVER_ORDINAL_NOT_FOUND ((NTSTATUS) 0xC0000262L)
-#endif
-
-#ifndef STATUS_DRIVER_ENTRYPOINT_NOT_FOUND
-# define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND ((NTSTATUS) 0xC0000263L)
-#endif
-
-#ifndef STATUS_RESOURCE_NOT_OWNED
-# define STATUS_RESOURCE_NOT_OWNED ((NTSTATUS) 0xC0000264L)
-#endif
-
-#ifndef STATUS_TOO_MANY_LINKS
-# define STATUS_TOO_MANY_LINKS ((NTSTATUS) 0xC0000265L)
-#endif
-
-#ifndef STATUS_QUOTA_LIST_INCONSISTENT
-# define STATUS_QUOTA_LIST_INCONSISTENT ((NTSTATUS) 0xC0000266L)
-#endif
-
-#ifndef STATUS_FILE_IS_OFFLINE
-# define STATUS_FILE_IS_OFFLINE ((NTSTATUS) 0xC0000267L)
-#endif
-
-#ifndef STATUS_EVALUATION_EXPIRATION
-# define STATUS_EVALUATION_EXPIRATION ((NTSTATUS) 0xC0000268L)
-#endif
-
-#ifndef STATUS_ILLEGAL_DLL_RELOCATION
-# define STATUS_ILLEGAL_DLL_RELOCATION ((NTSTATUS) 0xC0000269L)
-#endif
-
-#ifndef STATUS_LICENSE_VIOLATION
-# define STATUS_LICENSE_VIOLATION ((NTSTATUS) 0xC000026AL)
-#endif
-
-#ifndef STATUS_DLL_INIT_FAILED_LOGOFF
-# define STATUS_DLL_INIT_FAILED_LOGOFF ((NTSTATUS) 0xC000026BL)
-#endif
-
-#ifndef STATUS_DRIVER_UNABLE_TO_LOAD
-# define STATUS_DRIVER_UNABLE_TO_LOAD ((NTSTATUS) 0xC000026CL)
-#endif
-
-#ifndef STATUS_DFS_UNAVAILABLE
-# define STATUS_DFS_UNAVAILABLE ((NTSTATUS) 0xC000026DL)
-#endif
-
-#ifndef STATUS_VOLUME_DISMOUNTED
-# define STATUS_VOLUME_DISMOUNTED ((NTSTATUS) 0xC000026EL)
-#endif
-
-#ifndef STATUS_WX86_INTERNAL_ERROR
-# define STATUS_WX86_INTERNAL_ERROR ((NTSTATUS) 0xC000026FL)
-#endif
-
-#ifndef STATUS_WX86_FLOAT_STACK_CHECK
-# define STATUS_WX86_FLOAT_STACK_CHECK ((NTSTATUS) 0xC0000270L)
-#endif
-
-#ifndef STATUS_VALIDATE_CONTINUE
-# define STATUS_VALIDATE_CONTINUE ((NTSTATUS) 0xC0000271L)
-#endif
-
-#ifndef STATUS_NO_MATCH
-# define STATUS_NO_MATCH ((NTSTATUS) 0xC0000272L)
-#endif
-
-#ifndef STATUS_NO_MORE_MATCHES
-# define STATUS_NO_MORE_MATCHES ((NTSTATUS) 0xC0000273L)
-#endif
-
-#ifndef STATUS_NOT_A_REPARSE_POINT
-# define STATUS_NOT_A_REPARSE_POINT ((NTSTATUS) 0xC0000275L)
-#endif
-
-#ifndef STATUS_IO_REPARSE_TAG_INVALID
-# define STATUS_IO_REPARSE_TAG_INVALID ((NTSTATUS) 0xC0000276L)
-#endif
-
-#ifndef STATUS_IO_REPARSE_TAG_MISMATCH
-# define STATUS_IO_REPARSE_TAG_MISMATCH ((NTSTATUS) 0xC0000277L)
-#endif
-
-#ifndef STATUS_IO_REPARSE_DATA_INVALID
-# define STATUS_IO_REPARSE_DATA_INVALID ((NTSTATUS) 0xC0000278L)
-#endif
-
-#ifndef STATUS_IO_REPARSE_TAG_NOT_HANDLED
-# define STATUS_IO_REPARSE_TAG_NOT_HANDLED ((NTSTATUS) 0xC0000279L)
-#endif
-
-#ifndef STATUS_REPARSE_POINT_NOT_RESOLVED
-# define STATUS_REPARSE_POINT_NOT_RESOLVED ((NTSTATUS) 0xC0000280L)
-#endif
-
-#ifndef STATUS_DIRECTORY_IS_A_REPARSE_POINT
-# define STATUS_DIRECTORY_IS_A_REPARSE_POINT ((NTSTATUS) 0xC0000281L)
-#endif
-
-#ifndef STATUS_RANGE_LIST_CONFLICT
-# define STATUS_RANGE_LIST_CONFLICT ((NTSTATUS) 0xC0000282L)
-#endif
-
-#ifndef STATUS_SOURCE_ELEMENT_EMPTY
-# define STATUS_SOURCE_ELEMENT_EMPTY ((NTSTATUS) 0xC0000283L)
-#endif
-
-#ifndef STATUS_DESTINATION_ELEMENT_FULL
-# define STATUS_DESTINATION_ELEMENT_FULL ((NTSTATUS) 0xC0000284L)
-#endif
-
-#ifndef STATUS_ILLEGAL_ELEMENT_ADDRESS
-# define STATUS_ILLEGAL_ELEMENT_ADDRESS ((NTSTATUS) 0xC0000285L)
-#endif
-
-#ifndef STATUS_MAGAZINE_NOT_PRESENT
-# define STATUS_MAGAZINE_NOT_PRESENT ((NTSTATUS) 0xC0000286L)
-#endif
-
-#ifndef STATUS_REINITIALIZATION_NEEDED
-# define STATUS_REINITIALIZATION_NEEDED ((NTSTATUS) 0xC0000287L)
-#endif
-
-#ifndef STATUS_DEVICE_REQUIRES_CLEANING
-# define STATUS_DEVICE_REQUIRES_CLEANING ((NTSTATUS) 0x80000288L)
-#endif
-
-#ifndef STATUS_DEVICE_DOOR_OPEN
-# define STATUS_DEVICE_DOOR_OPEN ((NTSTATUS) 0x80000289L)
-#endif
-
-#ifndef STATUS_ENCRYPTION_FAILED
-# define STATUS_ENCRYPTION_FAILED ((NTSTATUS) 0xC000028AL)
-#endif
-
-#ifndef STATUS_DECRYPTION_FAILED
-# define STATUS_DECRYPTION_FAILED ((NTSTATUS) 0xC000028BL)
-#endif
-
-#ifndef STATUS_RANGE_NOT_FOUND
-# define STATUS_RANGE_NOT_FOUND ((NTSTATUS) 0xC000028CL)
-#endif
-
-#ifndef STATUS_NO_RECOVERY_POLICY
-# define STATUS_NO_RECOVERY_POLICY ((NTSTATUS) 0xC000028DL)
-#endif
-
-#ifndef STATUS_NO_EFS
-# define STATUS_NO_EFS ((NTSTATUS) 0xC000028EL)
-#endif
-
-#ifndef STATUS_WRONG_EFS
-# define STATUS_WRONG_EFS ((NTSTATUS) 0xC000028FL)
-#endif
-
-#ifndef STATUS_NO_USER_KEYS
-# define STATUS_NO_USER_KEYS ((NTSTATUS) 0xC0000290L)
-#endif
-
-#ifndef STATUS_FILE_NOT_ENCRYPTED
-# define STATUS_FILE_NOT_ENCRYPTED ((NTSTATUS) 0xC0000291L)
-#endif
-
-#ifndef STATUS_NOT_EXPORT_FORMAT
-# define STATUS_NOT_EXPORT_FORMAT ((NTSTATUS) 0xC0000292L)
-#endif
-
-#ifndef STATUS_FILE_ENCRYPTED
-# define STATUS_FILE_ENCRYPTED ((NTSTATUS) 0xC0000293L)
-#endif
-
-#ifndef STATUS_WAKE_SYSTEM
-# define STATUS_WAKE_SYSTEM ((NTSTATUS) 0x40000294L)
-#endif
-
-#ifndef STATUS_WMI_GUID_NOT_FOUND
-# define STATUS_WMI_GUID_NOT_FOUND ((NTSTATUS) 0xC0000295L)
-#endif
-
-#ifndef STATUS_WMI_INSTANCE_NOT_FOUND
-# define STATUS_WMI_INSTANCE_NOT_FOUND ((NTSTATUS) 0xC0000296L)
-#endif
-
-#ifndef STATUS_WMI_ITEMID_NOT_FOUND
-# define STATUS_WMI_ITEMID_NOT_FOUND ((NTSTATUS) 0xC0000297L)
-#endif
-
-#ifndef STATUS_WMI_TRY_AGAIN
-# define STATUS_WMI_TRY_AGAIN ((NTSTATUS) 0xC0000298L)
-#endif
-
-#ifndef STATUS_SHARED_POLICY
-# define STATUS_SHARED_POLICY ((NTSTATUS) 0xC0000299L)
-#endif
-
-#ifndef STATUS_POLICY_OBJECT_NOT_FOUND
-# define STATUS_POLICY_OBJECT_NOT_FOUND ((NTSTATUS) 0xC000029AL)
-#endif
-
-#ifndef STATUS_POLICY_ONLY_IN_DS
-# define STATUS_POLICY_ONLY_IN_DS ((NTSTATUS) 0xC000029BL)
-#endif
-
-#ifndef STATUS_VOLUME_NOT_UPGRADED
-# define STATUS_VOLUME_NOT_UPGRADED ((NTSTATUS) 0xC000029CL)
-#endif
-
-#ifndef STATUS_REMOTE_STORAGE_NOT_ACTIVE
-# define STATUS_REMOTE_STORAGE_NOT_ACTIVE ((NTSTATUS) 0xC000029DL)
-#endif
-
-#ifndef STATUS_REMOTE_STORAGE_MEDIA_ERROR
-# define STATUS_REMOTE_STORAGE_MEDIA_ERROR ((NTSTATUS) 0xC000029EL)
-#endif
-
-#ifndef STATUS_NO_TRACKING_SERVICE
-# define STATUS_NO_TRACKING_SERVICE ((NTSTATUS) 0xC000029FL)
-#endif
-
-#ifndef STATUS_SERVER_SID_MISMATCH
-# define STATUS_SERVER_SID_MISMATCH ((NTSTATUS) 0xC00002A0L)
-#endif
-
-#ifndef STATUS_DS_NO_ATTRIBUTE_OR_VALUE
-# define STATUS_DS_NO_ATTRIBUTE_OR_VALUE ((NTSTATUS) 0xC00002A1L)
-#endif
-
-#ifndef STATUS_DS_INVALID_ATTRIBUTE_SYNTAX
-# define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX ((NTSTATUS) 0xC00002A2L)
-#endif
-
-#ifndef STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED
-# define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED ((NTSTATUS) 0xC00002A3L)
-#endif
-
-#ifndef STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS
-# define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS ((NTSTATUS) 0xC00002A4L)
-#endif
-
-#ifndef STATUS_DS_BUSY
-# define STATUS_DS_BUSY ((NTSTATUS) 0xC00002A5L)
-#endif
-
-#ifndef STATUS_DS_UNAVAILABLE
-# define STATUS_DS_UNAVAILABLE ((NTSTATUS) 0xC00002A6L)
-#endif
-
-#ifndef STATUS_DS_NO_RIDS_ALLOCATED
-# define STATUS_DS_NO_RIDS_ALLOCATED ((NTSTATUS) 0xC00002A7L)
-#endif
-
-#ifndef STATUS_DS_NO_MORE_RIDS
-# define STATUS_DS_NO_MORE_RIDS ((NTSTATUS) 0xC00002A8L)
-#endif
-
-#ifndef STATUS_DS_INCORRECT_ROLE_OWNER
-# define STATUS_DS_INCORRECT_ROLE_OWNER ((NTSTATUS) 0xC00002A9L)
-#endif
-
-#ifndef STATUS_DS_RIDMGR_INIT_ERROR
-# define STATUS_DS_RIDMGR_INIT_ERROR ((NTSTATUS) 0xC00002AAL)
-#endif
-
-#ifndef STATUS_DS_OBJ_CLASS_VIOLATION
-# define STATUS_DS_OBJ_CLASS_VIOLATION ((NTSTATUS) 0xC00002ABL)
-#endif
-
-#ifndef STATUS_DS_CANT_ON_NON_LEAF
-# define STATUS_DS_CANT_ON_NON_LEAF ((NTSTATUS) 0xC00002ACL)
-#endif
-
-#ifndef STATUS_DS_CANT_ON_RDN
-# define STATUS_DS_CANT_ON_RDN ((NTSTATUS) 0xC00002ADL)
-#endif
-
-#ifndef STATUS_DS_CANT_MOD_OBJ_CLASS
-# define STATUS_DS_CANT_MOD_OBJ_CLASS ((NTSTATUS) 0xC00002AEL)
-#endif
-
-#ifndef STATUS_DS_CROSS_DOM_MOVE_FAILED
-# define STATUS_DS_CROSS_DOM_MOVE_FAILED ((NTSTATUS) 0xC00002AFL)
-#endif
-
-#ifndef STATUS_DS_GC_NOT_AVAILABLE
-# define STATUS_DS_GC_NOT_AVAILABLE ((NTSTATUS) 0xC00002B0L)
-#endif
-
-#ifndef STATUS_DIRECTORY_SERVICE_REQUIRED
-# define STATUS_DIRECTORY_SERVICE_REQUIRED ((NTSTATUS) 0xC00002B1L)
-#endif
-
-#ifndef STATUS_REPARSE_ATTRIBUTE_CONFLICT
-# define STATUS_REPARSE_ATTRIBUTE_CONFLICT ((NTSTATUS) 0xC00002B2L)
-#endif
-
-#ifndef STATUS_CANT_ENABLE_DENY_ONLY
-# define STATUS_CANT_ENABLE_DENY_ONLY ((NTSTATUS) 0xC00002B3L)
-#endif
-
-#ifndef STATUS_FLOAT_MULTIPLE_FAULTS
-# define STATUS_FLOAT_MULTIPLE_FAULTS ((NTSTATUS) 0xC00002B4L)
-#endif
-
-#ifndef STATUS_FLOAT_MULTIPLE_TRAPS
-# define STATUS_FLOAT_MULTIPLE_TRAPS ((NTSTATUS) 0xC00002B5L)
-#endif
-
-#ifndef STATUS_DEVICE_REMOVED
-# define STATUS_DEVICE_REMOVED ((NTSTATUS) 0xC00002B6L)
-#endif
-
-#ifndef STATUS_JOURNAL_DELETE_IN_PROGRESS
-# define STATUS_JOURNAL_DELETE_IN_PROGRESS ((NTSTATUS) 0xC00002B7L)
-#endif
-
-#ifndef STATUS_JOURNAL_NOT_ACTIVE
-# define STATUS_JOURNAL_NOT_ACTIVE ((NTSTATUS) 0xC00002B8L)
-#endif
-
-#ifndef STATUS_NOINTERFACE
-# define STATUS_NOINTERFACE ((NTSTATUS) 0xC00002B9L)
-#endif
-
-#ifndef STATUS_DS_ADMIN_LIMIT_EXCEEDED
-# define STATUS_DS_ADMIN_LIMIT_EXCEEDED ((NTSTATUS) 0xC00002C1L)
-#endif
-
-#ifndef STATUS_DRIVER_FAILED_SLEEP
-# define STATUS_DRIVER_FAILED_SLEEP ((NTSTATUS) 0xC00002C2L)
-#endif
-
-#ifndef STATUS_MUTUAL_AUTHENTICATION_FAILED
-# define STATUS_MUTUAL_AUTHENTICATION_FAILED ((NTSTATUS) 0xC00002C3L)
-#endif
-
-#ifndef STATUS_CORRUPT_SYSTEM_FILE
-# define STATUS_CORRUPT_SYSTEM_FILE ((NTSTATUS) 0xC00002C4L)
-#endif
-
-#ifndef STATUS_DATATYPE_MISALIGNMENT_ERROR
-# define STATUS_DATATYPE_MISALIGNMENT_ERROR ((NTSTATUS) 0xC00002C5L)
-#endif
-
-#ifndef STATUS_WMI_READ_ONLY
-# define STATUS_WMI_READ_ONLY ((NTSTATUS) 0xC00002C6L)
-#endif
-
-#ifndef STATUS_WMI_SET_FAILURE
-# define STATUS_WMI_SET_FAILURE ((NTSTATUS) 0xC00002C7L)
-#endif
-
-#ifndef STATUS_COMMITMENT_MINIMUM
-# define STATUS_COMMITMENT_MINIMUM ((NTSTATUS) 0xC00002C8L)
-#endif
-
-#ifndef STATUS_REG_NAT_CONSUMPTION
-# define STATUS_REG_NAT_CONSUMPTION ((NTSTATUS) 0xC00002C9L)
-#endif
-
-#ifndef STATUS_TRANSPORT_FULL
-# define STATUS_TRANSPORT_FULL ((NTSTATUS) 0xC00002CAL)
-#endif
-
-#ifndef STATUS_DS_SAM_INIT_FAILURE
-# define STATUS_DS_SAM_INIT_FAILURE ((NTSTATUS) 0xC00002CBL)
-#endif
-
-#ifndef STATUS_ONLY_IF_CONNECTED
-# define STATUS_ONLY_IF_CONNECTED ((NTSTATUS) 0xC00002CCL)
-#endif
-
-#ifndef STATUS_DS_SENSITIVE_GROUP_VIOLATION
-# define STATUS_DS_SENSITIVE_GROUP_VIOLATION ((NTSTATUS) 0xC00002CDL)
-#endif
-
-#ifndef STATUS_PNP_RESTART_ENUMERATION
-# define STATUS_PNP_RESTART_ENUMERATION ((NTSTATUS) 0xC00002CEL)
-#endif
-
-#ifndef STATUS_JOURNAL_ENTRY_DELETED
-# define STATUS_JOURNAL_ENTRY_DELETED ((NTSTATUS) 0xC00002CFL)
-#endif
-
-#ifndef STATUS_DS_CANT_MOD_PRIMARYGROUPID
-# define STATUS_DS_CANT_MOD_PRIMARYGROUPID ((NTSTATUS) 0xC00002D0L)
-#endif
-
-#ifndef STATUS_SYSTEM_IMAGE_BAD_SIGNATURE
-# define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE ((NTSTATUS) 0xC00002D1L)
-#endif
-
-#ifndef STATUS_PNP_REBOOT_REQUIRED
-# define STATUS_PNP_REBOOT_REQUIRED ((NTSTATUS) 0xC00002D2L)
-#endif
-
-#ifndef STATUS_POWER_STATE_INVALID
-# define STATUS_POWER_STATE_INVALID ((NTSTATUS) 0xC00002D3L)
-#endif
-
-#ifndef STATUS_DS_INVALID_GROUP_TYPE
-# define STATUS_DS_INVALID_GROUP_TYPE ((NTSTATUS) 0xC00002D4L)
-#endif
-
-#ifndef STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN
-# define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN ((NTSTATUS) 0xC00002D5L)
-#endif
-
-#ifndef STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN
-# define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN ((NTSTATUS) 0xC00002D6L)
-#endif
-
-#ifndef STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER
-# define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER ((NTSTATUS) 0xC00002D7L)
-#endif
-
-#ifndef STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER
-# define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER ((NTSTATUS) 0xC00002D8L)
-#endif
-
-#ifndef STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER
-# define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER ((NTSTATUS) 0xC00002D9L)
-#endif
-
-#ifndef STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER
-# define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER ((NTSTATUS) 0xC00002DAL)
-#endif
-
-#ifndef STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER
-# define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER ((NTSTATUS) 0xC00002DBL)
-#endif
-
-#ifndef STATUS_DS_HAVE_PRIMARY_MEMBERS
-# define STATUS_DS_HAVE_PRIMARY_MEMBERS ((NTSTATUS) 0xC00002DCL)
-#endif
-
-#ifndef STATUS_WMI_NOT_SUPPORTED
-# define STATUS_WMI_NOT_SUPPORTED ((NTSTATUS) 0xC00002DDL)
-#endif
-
-#ifndef STATUS_INSUFFICIENT_POWER
-# define STATUS_INSUFFICIENT_POWER ((NTSTATUS) 0xC00002DEL)
-#endif
-
-#ifndef STATUS_SAM_NEED_BOOTKEY_PASSWORD
-# define STATUS_SAM_NEED_BOOTKEY_PASSWORD ((NTSTATUS) 0xC00002DFL)
-#endif
-
-#ifndef STATUS_SAM_NEED_BOOTKEY_FLOPPY
-# define STATUS_SAM_NEED_BOOTKEY_FLOPPY ((NTSTATUS) 0xC00002E0L)
-#endif
-
-#ifndef STATUS_DS_CANT_START
-# define STATUS_DS_CANT_START ((NTSTATUS) 0xC00002E1L)
-#endif
-
-#ifndef STATUS_DS_INIT_FAILURE
-# define STATUS_DS_INIT_FAILURE ((NTSTATUS) 0xC00002E2L)
-#endif
-
-#ifndef STATUS_SAM_INIT_FAILURE
-# define STATUS_SAM_INIT_FAILURE ((NTSTATUS) 0xC00002E3L)
-#endif
-
-#ifndef STATUS_DS_GC_REQUIRED
-# define STATUS_DS_GC_REQUIRED ((NTSTATUS) 0xC00002E4L)
-#endif
-
-#ifndef STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY
-# define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY ((NTSTATUS) 0xC00002E5L)
-#endif
-
-#ifndef STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS
-# define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS ((NTSTATUS) 0xC00002E6L)
-#endif
-
-#ifndef STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED
-# define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED ((NTSTATUS) 0xC00002E7L)
-#endif
-
-#ifndef STATUS_MULTIPLE_FAULT_VIOLATION
-# define STATUS_MULTIPLE_FAULT_VIOLATION ((NTSTATUS) 0xC00002E8L)
-#endif
-
-#ifndef STATUS_CURRENT_DOMAIN_NOT_ALLOWED
-# define STATUS_CURRENT_DOMAIN_NOT_ALLOWED ((NTSTATUS) 0xC00002E9L)
-#endif
-
-#ifndef STATUS_CANNOT_MAKE
-# define STATUS_CANNOT_MAKE ((NTSTATUS) 0xC00002EAL)
-#endif
-
-#ifndef STATUS_SYSTEM_SHUTDOWN
-# define STATUS_SYSTEM_SHUTDOWN ((NTSTATUS) 0xC00002EBL)
-#endif
-
-#ifndef STATUS_DS_INIT_FAILURE_CONSOLE
-# define STATUS_DS_INIT_FAILURE_CONSOLE ((NTSTATUS) 0xC00002ECL)
-#endif
-
-#ifndef STATUS_DS_SAM_INIT_FAILURE_CONSOLE
-# define STATUS_DS_SAM_INIT_FAILURE_CONSOLE ((NTSTATUS) 0xC00002EDL)
-#endif
-
-#ifndef STATUS_UNFINISHED_CONTEXT_DELETED
-# define STATUS_UNFINISHED_CONTEXT_DELETED ((NTSTATUS) 0xC00002EEL)
-#endif
-
-#ifndef STATUS_NO_TGT_REPLY
-# define STATUS_NO_TGT_REPLY ((NTSTATUS) 0xC00002EFL)
-#endif
-
-#ifndef STATUS_OBJECTID_NOT_FOUND
-# define STATUS_OBJECTID_NOT_FOUND ((NTSTATUS) 0xC00002F0L)
-#endif
-
-#ifndef STATUS_NO_IP_ADDRESSES
-# define STATUS_NO_IP_ADDRESSES ((NTSTATUS) 0xC00002F1L)
-#endif
-
-#ifndef STATUS_WRONG_CREDENTIAL_HANDLE
-# define STATUS_WRONG_CREDENTIAL_HANDLE ((NTSTATUS) 0xC00002F2L)
-#endif
-
-#ifndef STATUS_CRYPTO_SYSTEM_INVALID
-# define STATUS_CRYPTO_SYSTEM_INVALID ((NTSTATUS) 0xC00002F3L)
-#endif
-
-#ifndef STATUS_MAX_REFERRALS_EXCEEDED
-# define STATUS_MAX_REFERRALS_EXCEEDED ((NTSTATUS) 0xC00002F4L)
-#endif
-
-#ifndef STATUS_MUST_BE_KDC
-# define STATUS_MUST_BE_KDC ((NTSTATUS) 0xC00002F5L)
-#endif
-
-#ifndef STATUS_STRONG_CRYPTO_NOT_SUPPORTED
-# define STATUS_STRONG_CRYPTO_NOT_SUPPORTED ((NTSTATUS) 0xC00002F6L)
-#endif
-
-#ifndef STATUS_TOO_MANY_PRINCIPALS
-# define STATUS_TOO_MANY_PRINCIPALS ((NTSTATUS) 0xC00002F7L)
-#endif
-
-#ifndef STATUS_NO_PA_DATA
-# define STATUS_NO_PA_DATA ((NTSTATUS) 0xC00002F8L)
-#endif
-
-#ifndef STATUS_PKINIT_NAME_MISMATCH
-# define STATUS_PKINIT_NAME_MISMATCH ((NTSTATUS) 0xC00002F9L)
-#endif
-
-#ifndef STATUS_SMARTCARD_LOGON_REQUIRED
-# define STATUS_SMARTCARD_LOGON_REQUIRED ((NTSTATUS) 0xC00002FAL)
-#endif
-
-#ifndef STATUS_KDC_INVALID_REQUEST
-# define STATUS_KDC_INVALID_REQUEST ((NTSTATUS) 0xC00002FBL)
-#endif
-
-#ifndef STATUS_KDC_UNABLE_TO_REFER
-# define STATUS_KDC_UNABLE_TO_REFER ((NTSTATUS) 0xC00002FCL)
-#endif
-
-#ifndef STATUS_KDC_UNKNOWN_ETYPE
-# define STATUS_KDC_UNKNOWN_ETYPE ((NTSTATUS) 0xC00002FDL)
-#endif
-
-#ifndef STATUS_SHUTDOWN_IN_PROGRESS
-# define STATUS_SHUTDOWN_IN_PROGRESS ((NTSTATUS) 0xC00002FEL)
-#endif
-
-#ifndef STATUS_SERVER_SHUTDOWN_IN_PROGRESS
-# define STATUS_SERVER_SHUTDOWN_IN_PROGRESS ((NTSTATUS) 0xC00002FFL)
-#endif
-
-#ifndef STATUS_NOT_SUPPORTED_ON_SBS
-# define STATUS_NOT_SUPPORTED_ON_SBS ((NTSTATUS) 0xC0000300L)
-#endif
-
-#ifndef STATUS_WMI_GUID_DISCONNECTED
-# define STATUS_WMI_GUID_DISCONNECTED ((NTSTATUS) 0xC0000301L)
-#endif
-
-#ifndef STATUS_WMI_ALREADY_DISABLED
-# define STATUS_WMI_ALREADY_DISABLED ((NTSTATUS) 0xC0000302L)
-#endif
-
-#ifndef STATUS_WMI_ALREADY_ENABLED
-# define STATUS_WMI_ALREADY_ENABLED ((NTSTATUS) 0xC0000303L)
-#endif
-
-#ifndef STATUS_MFT_TOO_FRAGMENTED
-# define STATUS_MFT_TOO_FRAGMENTED ((NTSTATUS) 0xC0000304L)
-#endif
-
-#ifndef STATUS_COPY_PROTECTION_FAILURE
-# define STATUS_COPY_PROTECTION_FAILURE ((NTSTATUS) 0xC0000305L)
-#endif
-
-#ifndef STATUS_CSS_AUTHENTICATION_FAILURE
-# define STATUS_CSS_AUTHENTICATION_FAILURE ((NTSTATUS) 0xC0000306L)
-#endif
-
-#ifndef STATUS_CSS_KEY_NOT_PRESENT
-# define STATUS_CSS_KEY_NOT_PRESENT ((NTSTATUS) 0xC0000307L)
-#endif
-
-#ifndef STATUS_CSS_KEY_NOT_ESTABLISHED
-# define STATUS_CSS_KEY_NOT_ESTABLISHED ((NTSTATUS) 0xC0000308L)
-#endif
-
-#ifndef STATUS_CSS_SCRAMBLED_SECTOR
-# define STATUS_CSS_SCRAMBLED_SECTOR ((NTSTATUS) 0xC0000309L)
-#endif
-
-#ifndef STATUS_CSS_REGION_MISMATCH
-# define STATUS_CSS_REGION_MISMATCH ((NTSTATUS) 0xC000030AL)
-#endif
-
-#ifndef STATUS_CSS_RESETS_EXHAUSTED
-# define STATUS_CSS_RESETS_EXHAUSTED ((NTSTATUS) 0xC000030BL)
-#endif
-
-#ifndef STATUS_PKINIT_FAILURE
-# define STATUS_PKINIT_FAILURE ((NTSTATUS) 0xC0000320L)
-#endif
-
-#ifndef STATUS_SMARTCARD_SUBSYSTEM_FAILURE
-# define STATUS_SMARTCARD_SUBSYSTEM_FAILURE ((NTSTATUS) 0xC0000321L)
-#endif
-
-#ifndef STATUS_NO_KERB_KEY
-# define STATUS_NO_KERB_KEY ((NTSTATUS) 0xC0000322L)
-#endif
-
-#ifndef STATUS_HOST_DOWN
-# define STATUS_HOST_DOWN ((NTSTATUS) 0xC0000350L)
-#endif
-
-#ifndef STATUS_UNSUPPORTED_PREAUTH
-# define STATUS_UNSUPPORTED_PREAUTH ((NTSTATUS) 0xC0000351L)
-#endif
-
-#ifndef STATUS_EFS_ALG_BLOB_TOO_BIG
-# define STATUS_EFS_ALG_BLOB_TOO_BIG ((NTSTATUS) 0xC0000352L)
-#endif
-
-#ifndef STATUS_PORT_NOT_SET
-# define STATUS_PORT_NOT_SET ((NTSTATUS) 0xC0000353L)
-#endif
-
-#ifndef STATUS_DEBUGGER_INACTIVE
-# define STATUS_DEBUGGER_INACTIVE ((NTSTATUS) 0xC0000354L)
-#endif
-
-#ifndef STATUS_DS_VERSION_CHECK_FAILURE
-# define STATUS_DS_VERSION_CHECK_FAILURE ((NTSTATUS) 0xC0000355L)
-#endif
-
-#ifndef STATUS_AUDITING_DISABLED
-# define STATUS_AUDITING_DISABLED ((NTSTATUS) 0xC0000356L)
-#endif
-
-#ifndef STATUS_PRENT4_MACHINE_ACCOUNT
-# define STATUS_PRENT4_MACHINE_ACCOUNT ((NTSTATUS) 0xC0000357L)
-#endif
-
-#ifndef STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER
-# define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER ((NTSTATUS) 0xC0000358L)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_WIN_32
-# define STATUS_INVALID_IMAGE_WIN_32 ((NTSTATUS) 0xC0000359L)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_WIN_64
-# define STATUS_INVALID_IMAGE_WIN_64 ((NTSTATUS) 0xC000035AL)
-#endif
-
-#ifndef STATUS_BAD_BINDINGS
-# define STATUS_BAD_BINDINGS ((NTSTATUS) 0xC000035BL)
-#endif
-
-#ifndef STATUS_NETWORK_SESSION_EXPIRED
-# define STATUS_NETWORK_SESSION_EXPIRED ((NTSTATUS) 0xC000035CL)
-#endif
-
-#ifndef STATUS_APPHELP_BLOCK
-# define STATUS_APPHELP_BLOCK ((NTSTATUS) 0xC000035DL)
-#endif
-
-#ifndef STATUS_ALL_SIDS_FILTERED
-# define STATUS_ALL_SIDS_FILTERED ((NTSTATUS) 0xC000035EL)
-#endif
-
-#ifndef STATUS_NOT_SAFE_MODE_DRIVER
-# define STATUS_NOT_SAFE_MODE_DRIVER ((NTSTATUS) 0xC000035FL)
-#endif
-
-#ifndef STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT
-# define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT ((NTSTATUS) 0xC0000361L)
-#endif
-
-#ifndef STATUS_ACCESS_DISABLED_BY_POLICY_PATH
-# define STATUS_ACCESS_DISABLED_BY_POLICY_PATH ((NTSTATUS) 0xC0000362L)
-#endif
-
-#ifndef STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER
-# define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER ((NTSTATUS) 0xC0000363L)
-#endif
-
-#ifndef STATUS_ACCESS_DISABLED_BY_POLICY_OTHER
-# define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER ((NTSTATUS) 0xC0000364L)
-#endif
-
-#ifndef STATUS_FAILED_DRIVER_ENTRY
-# define STATUS_FAILED_DRIVER_ENTRY ((NTSTATUS) 0xC0000365L)
-#endif
-
-#ifndef STATUS_DEVICE_ENUMERATION_ERROR
-# define STATUS_DEVICE_ENUMERATION_ERROR ((NTSTATUS) 0xC0000366L)
-#endif
-
-#ifndef STATUS_MOUNT_POINT_NOT_RESOLVED
-# define STATUS_MOUNT_POINT_NOT_RESOLVED ((NTSTATUS) 0xC0000368L)
-#endif
-
-#ifndef STATUS_INVALID_DEVICE_OBJECT_PARAMETER
-# define STATUS_INVALID_DEVICE_OBJECT_PARAMETER ((NTSTATUS) 0xC0000369L)
-#endif
-
-#ifndef STATUS_MCA_OCCURED
-# define STATUS_MCA_OCCURED ((NTSTATUS) 0xC000036AL)
-#endif
-
-#ifndef STATUS_DRIVER_BLOCKED_CRITICAL
-# define STATUS_DRIVER_BLOCKED_CRITICAL ((NTSTATUS) 0xC000036BL)
-#endif
-
-#ifndef STATUS_DRIVER_BLOCKED
-# define STATUS_DRIVER_BLOCKED ((NTSTATUS) 0xC000036CL)
-#endif
-
-#ifndef STATUS_DRIVER_DATABASE_ERROR
-# define STATUS_DRIVER_DATABASE_ERROR ((NTSTATUS) 0xC000036DL)
-#endif
-
-#ifndef STATUS_SYSTEM_HIVE_TOO_LARGE
-# define STATUS_SYSTEM_HIVE_TOO_LARGE ((NTSTATUS) 0xC000036EL)
-#endif
-
-#ifndef STATUS_INVALID_IMPORT_OF_NON_DLL
-# define STATUS_INVALID_IMPORT_OF_NON_DLL ((NTSTATUS) 0xC000036FL)
-#endif
-
-#ifndef STATUS_DS_SHUTTING_DOWN
-# define STATUS_DS_SHUTTING_DOWN ((NTSTATUS) 0x40000370L)
-#endif
-
-#ifndef STATUS_NO_SECRETS
-# define STATUS_NO_SECRETS ((NTSTATUS) 0xC0000371L)
-#endif
-
-#ifndef STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY
-# define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY ((NTSTATUS) 0xC0000372L)
-#endif
-
-#ifndef STATUS_FAILED_STACK_SWITCH
-# define STATUS_FAILED_STACK_SWITCH ((NTSTATUS) 0xC0000373L)
-#endif
-
-#ifndef STATUS_HEAP_CORRUPTION
-# define STATUS_HEAP_CORRUPTION ((NTSTATUS) 0xC0000374L)
-#endif
-
-#ifndef STATUS_SMARTCARD_WRONG_PIN
-# define STATUS_SMARTCARD_WRONG_PIN ((NTSTATUS) 0xC0000380L)
-#endif
-
-#ifndef STATUS_SMARTCARD_CARD_BLOCKED
-# define STATUS_SMARTCARD_CARD_BLOCKED ((NTSTATUS) 0xC0000381L)
-#endif
-
-#ifndef STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED
-# define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED ((NTSTATUS) 0xC0000382L)
-#endif
-
-#ifndef STATUS_SMARTCARD_NO_CARD
-# define STATUS_SMARTCARD_NO_CARD ((NTSTATUS) 0xC0000383L)
-#endif
-
-#ifndef STATUS_SMARTCARD_NO_KEY_CONTAINER
-# define STATUS_SMARTCARD_NO_KEY_CONTAINER ((NTSTATUS) 0xC0000384L)
-#endif
-
-#ifndef STATUS_SMARTCARD_NO_CERTIFICATE
-# define STATUS_SMARTCARD_NO_CERTIFICATE ((NTSTATUS) 0xC0000385L)
-#endif
-
-#ifndef STATUS_SMARTCARD_NO_KEYSET
-# define STATUS_SMARTCARD_NO_KEYSET ((NTSTATUS) 0xC0000386L)
-#endif
-
-#ifndef STATUS_SMARTCARD_IO_ERROR
-# define STATUS_SMARTCARD_IO_ERROR ((NTSTATUS) 0xC0000387L)
-#endif
-
-#ifndef STATUS_DOWNGRADE_DETECTED
-# define STATUS_DOWNGRADE_DETECTED ((NTSTATUS) 0xC0000388L)
-#endif
-
-#ifndef STATUS_SMARTCARD_CERT_REVOKED
-# define STATUS_SMARTCARD_CERT_REVOKED ((NTSTATUS) 0xC0000389L)
-#endif
-
-#ifndef STATUS_ISSUING_CA_UNTRUSTED
-# define STATUS_ISSUING_CA_UNTRUSTED ((NTSTATUS) 0xC000038AL)
-#endif
-
-#ifndef STATUS_REVOCATION_OFFLINE_C
-# define STATUS_REVOCATION_OFFLINE_C ((NTSTATUS) 0xC000038BL)
-#endif
-
-#ifndef STATUS_PKINIT_CLIENT_FAILURE
-# define STATUS_PKINIT_CLIENT_FAILURE ((NTSTATUS) 0xC000038CL)
-#endif
-
-#ifndef STATUS_SMARTCARD_CERT_EXPIRED
-# define STATUS_SMARTCARD_CERT_EXPIRED ((NTSTATUS) 0xC000038DL)
-#endif
-
-#ifndef STATUS_DRIVER_FAILED_PRIOR_UNLOAD
-# define STATUS_DRIVER_FAILED_PRIOR_UNLOAD ((NTSTATUS) 0xC000038EL)
-#endif
-
-#ifndef STATUS_SMARTCARD_SILENT_CONTEXT
-# define STATUS_SMARTCARD_SILENT_CONTEXT ((NTSTATUS) 0xC000038FL)
-#endif
-
-#ifndef STATUS_PER_USER_TRUST_QUOTA_EXCEEDED
-# define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000401L)
-#endif
-
-#ifndef STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED
-# define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000402L)
-#endif
-
-#ifndef STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED
-# define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000403L)
-#endif
-
-#ifndef STATUS_DS_NAME_NOT_UNIQUE
-# define STATUS_DS_NAME_NOT_UNIQUE ((NTSTATUS) 0xC0000404L)
-#endif
-
-#ifndef STATUS_DS_DUPLICATE_ID_FOUND
-# define STATUS_DS_DUPLICATE_ID_FOUND ((NTSTATUS) 0xC0000405L)
-#endif
-
-#ifndef STATUS_DS_GROUP_CONVERSION_ERROR
-# define STATUS_DS_GROUP_CONVERSION_ERROR ((NTSTATUS) 0xC0000406L)
-#endif
-
-#ifndef STATUS_VOLSNAP_PREPARE_HIBERNATE
-# define STATUS_VOLSNAP_PREPARE_HIBERNATE ((NTSTATUS) 0xC0000407L)
-#endif
-
-#ifndef STATUS_USER2USER_REQUIRED
-# define STATUS_USER2USER_REQUIRED ((NTSTATUS) 0xC0000408L)
-#endif
-
-#ifndef STATUS_STACK_BUFFER_OVERRUN
-# define STATUS_STACK_BUFFER_OVERRUN ((NTSTATUS) 0xC0000409L)
-#endif
-
-#ifndef STATUS_NO_S4U_PROT_SUPPORT
-# define STATUS_NO_S4U_PROT_SUPPORT ((NTSTATUS) 0xC000040AL)
-#endif
-
-#ifndef STATUS_CROSSREALM_DELEGATION_FAILURE
-# define STATUS_CROSSREALM_DELEGATION_FAILURE ((NTSTATUS) 0xC000040BL)
-#endif
-
-#ifndef STATUS_REVOCATION_OFFLINE_KDC
-# define STATUS_REVOCATION_OFFLINE_KDC ((NTSTATUS) 0xC000040CL)
-#endif
-
-#ifndef STATUS_ISSUING_CA_UNTRUSTED_KDC
-# define STATUS_ISSUING_CA_UNTRUSTED_KDC ((NTSTATUS) 0xC000040DL)
-#endif
-
-#ifndef STATUS_KDC_CERT_EXPIRED
-# define STATUS_KDC_CERT_EXPIRED ((NTSTATUS) 0xC000040EL)
-#endif
-
-#ifndef STATUS_KDC_CERT_REVOKED
-# define STATUS_KDC_CERT_REVOKED ((NTSTATUS) 0xC000040FL)
-#endif
-
-#ifndef STATUS_PARAMETER_QUOTA_EXCEEDED
-# define STATUS_PARAMETER_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000410L)
-#endif
-
-#ifndef STATUS_HIBERNATION_FAILURE
-# define STATUS_HIBERNATION_FAILURE ((NTSTATUS) 0xC0000411L)
-#endif
-
-#ifndef STATUS_DELAY_LOAD_FAILED
-# define STATUS_DELAY_LOAD_FAILED ((NTSTATUS) 0xC0000412L)
-#endif
-
-#ifndef STATUS_AUTHENTICATION_FIREWALL_FAILED
-# define STATUS_AUTHENTICATION_FIREWALL_FAILED ((NTSTATUS) 0xC0000413L)
-#endif
-
-#ifndef STATUS_VDM_DISALLOWED
-# define STATUS_VDM_DISALLOWED ((NTSTATUS) 0xC0000414L)
-#endif
-
-#ifndef STATUS_HUNG_DISPLAY_DRIVER_THREAD
-# define STATUS_HUNG_DISPLAY_DRIVER_THREAD ((NTSTATUS) 0xC0000415L)
-#endif
-
-#ifndef STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE
-# define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE ((NTSTATUS) 0xC0000416L)
-#endif
-
-#ifndef STATUS_INVALID_CRUNTIME_PARAMETER
-# define STATUS_INVALID_CRUNTIME_PARAMETER ((NTSTATUS) 0xC0000417L)
-#endif
-
-#ifndef STATUS_NTLM_BLOCKED
-# define STATUS_NTLM_BLOCKED ((NTSTATUS) 0xC0000418L)
-#endif
-
-#ifndef STATUS_DS_SRC_SID_EXISTS_IN_FOREST
-# define STATUS_DS_SRC_SID_EXISTS_IN_FOREST ((NTSTATUS) 0xC0000419L)
-#endif
-
-#ifndef STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST
-# define STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST ((NTSTATUS) 0xC000041AL)
-#endif
-
-#ifndef STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST
-# define STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST ((NTSTATUS) 0xC000041BL)
-#endif
-
-#ifndef STATUS_INVALID_USER_PRINCIPAL_NAME
-# define STATUS_INVALID_USER_PRINCIPAL_NAME ((NTSTATUS) 0xC000041CL)
-#endif
-
-#ifndef STATUS_FATAL_USER_CALLBACK_EXCEPTION
-# define STATUS_FATAL_USER_CALLBACK_EXCEPTION ((NTSTATUS) 0xC000041DL)
-#endif
-
-#ifndef STATUS_ASSERTION_FAILURE
-# define STATUS_ASSERTION_FAILURE ((NTSTATUS) 0xC0000420L)
-#endif
-
-#ifndef STATUS_VERIFIER_STOP
-# define STATUS_VERIFIER_STOP ((NTSTATUS) 0xC0000421L)
-#endif
-
-#ifndef STATUS_CALLBACK_POP_STACK
-# define STATUS_CALLBACK_POP_STACK ((NTSTATUS) 0xC0000423L)
-#endif
-
-#ifndef STATUS_INCOMPATIBLE_DRIVER_BLOCKED
-# define STATUS_INCOMPATIBLE_DRIVER_BLOCKED ((NTSTATUS) 0xC0000424L)
-#endif
-
-#ifndef STATUS_HIVE_UNLOADED
-# define STATUS_HIVE_UNLOADED ((NTSTATUS) 0xC0000425L)
-#endif
-
-#ifndef STATUS_COMPRESSION_DISABLED
-# define STATUS_COMPRESSION_DISABLED ((NTSTATUS) 0xC0000426L)
-#endif
-
-#ifndef STATUS_FILE_SYSTEM_LIMITATION
-# define STATUS_FILE_SYSTEM_LIMITATION ((NTSTATUS) 0xC0000427L)
-#endif
-
-#ifndef STATUS_INVALID_IMAGE_HASH
-# define STATUS_INVALID_IMAGE_HASH ((NTSTATUS) 0xC0000428L)
-#endif
-
-#ifndef STATUS_NOT_CAPABLE
-# define STATUS_NOT_CAPABLE ((NTSTATUS) 0xC0000429L)
-#endif
-
-#ifndef STATUS_REQUEST_OUT_OF_SEQUENCE
-# define STATUS_REQUEST_OUT_OF_SEQUENCE ((NTSTATUS) 0xC000042AL)
-#endif
-
-#ifndef STATUS_IMPLEMENTATION_LIMIT
-# define STATUS_IMPLEMENTATION_LIMIT ((NTSTATUS) 0xC000042BL)
-#endif
-
-#ifndef STATUS_ELEVATION_REQUIRED
-# define STATUS_ELEVATION_REQUIRED ((NTSTATUS) 0xC000042CL)
-#endif
-
-#ifndef STATUS_NO_SECURITY_CONTEXT
-# define STATUS_NO_SECURITY_CONTEXT ((NTSTATUS) 0xC000042DL)
-#endif
-
-#ifndef STATUS_PKU2U_CERT_FAILURE
-# define STATUS_PKU2U_CERT_FAILURE ((NTSTATUS) 0xC000042FL)
-#endif
-
-#ifndef STATUS_BEYOND_VDL
-# define STATUS_BEYOND_VDL ((NTSTATUS) 0xC0000432L)
-#endif
-
-#ifndef STATUS_ENCOUNTERED_WRITE_IN_PROGRESS
-# define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS ((NTSTATUS) 0xC0000433L)
-#endif
-
-#ifndef STATUS_PTE_CHANGED
-# define STATUS_PTE_CHANGED ((NTSTATUS) 0xC0000434L)
-#endif
-
-#ifndef STATUS_PURGE_FAILED
-# define STATUS_PURGE_FAILED ((NTSTATUS) 0xC0000435L)
-#endif
-
-#ifndef STATUS_CRED_REQUIRES_CONFIRMATION
-# define STATUS_CRED_REQUIRES_CONFIRMATION ((NTSTATUS) 0xC0000440L)
-#endif
-
-#ifndef STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE
-# define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE ((NTSTATUS) 0xC0000441L)
-#endif
-
-#ifndef STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER
-# define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER ((NTSTATUS) 0xC0000442L)
-#endif
-
-#ifndef STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE
-# define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE ((NTSTATUS) 0xC0000443L)
-#endif
-
-#ifndef STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE
-# define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE ((NTSTATUS) 0xC0000444L)
-#endif
-
-#ifndef STATUS_CS_ENCRYPTION_FILE_NOT_CSE
-# define STATUS_CS_ENCRYPTION_FILE_NOT_CSE ((NTSTATUS) 0xC0000445L)
-#endif
-
-#ifndef STATUS_INVALID_LABEL
-# define STATUS_INVALID_LABEL ((NTSTATUS) 0xC0000446L)
-#endif
-
-#ifndef STATUS_DRIVER_PROCESS_TERMINATED
-# define STATUS_DRIVER_PROCESS_TERMINATED ((NTSTATUS) 0xC0000450L)
-#endif
-
-#ifndef STATUS_AMBIGUOUS_SYSTEM_DEVICE
-# define STATUS_AMBIGUOUS_SYSTEM_DEVICE ((NTSTATUS) 0xC0000451L)
-#endif
-
-#ifndef STATUS_SYSTEM_DEVICE_NOT_FOUND
-# define STATUS_SYSTEM_DEVICE_NOT_FOUND ((NTSTATUS) 0xC0000452L)
-#endif
-
-#ifndef STATUS_RESTART_BOOT_APPLICATION
-# define STATUS_RESTART_BOOT_APPLICATION ((NTSTATUS) 0xC0000453L)
-#endif
-
-#ifndef STATUS_INSUFFICIENT_NVRAM_RESOURCES
-# define STATUS_INSUFFICIENT_NVRAM_RESOURCES ((NTSTATUS) 0xC0000454L)
-#endif
-
-#ifndef STATUS_INVALID_TASK_NAME
-# define STATUS_INVALID_TASK_NAME ((NTSTATUS) 0xC0000500L)
-#endif
-
-#ifndef STATUS_INVALID_TASK_INDEX
-# define STATUS_INVALID_TASK_INDEX ((NTSTATUS) 0xC0000501L)
-#endif
-
-#ifndef STATUS_THREAD_ALREADY_IN_TASK
-# define STATUS_THREAD_ALREADY_IN_TASK ((NTSTATUS) 0xC0000502L)
-#endif
-
-#ifndef STATUS_CALLBACK_BYPASS
-# define STATUS_CALLBACK_BYPASS ((NTSTATUS) 0xC0000503L)
-#endif
-
-#ifndef STATUS_FAIL_FAST_EXCEPTION
-# define STATUS_FAIL_FAST_EXCEPTION ((NTSTATUS) 0xC0000602L)
-#endif
-
-#ifndef STATUS_IMAGE_CERT_REVOKED
-# define STATUS_IMAGE_CERT_REVOKED ((NTSTATUS) 0xC0000603L)
-#endif
-
-#ifndef STATUS_PORT_CLOSED
-# define STATUS_PORT_CLOSED ((NTSTATUS) 0xC0000700L)
-#endif
-
-#ifndef STATUS_MESSAGE_LOST
-# define STATUS_MESSAGE_LOST ((NTSTATUS) 0xC0000701L)
-#endif
-
-#ifndef STATUS_INVALID_MESSAGE
-# define STATUS_INVALID_MESSAGE ((NTSTATUS) 0xC0000702L)
-#endif
-
-#ifndef STATUS_REQUEST_CANCELED
-# define STATUS_REQUEST_CANCELED ((NTSTATUS) 0xC0000703L)
-#endif
-
-#ifndef STATUS_RECURSIVE_DISPATCH
-# define STATUS_RECURSIVE_DISPATCH ((NTSTATUS) 0xC0000704L)
-#endif
-
-#ifndef STATUS_LPC_RECEIVE_BUFFER_EXPECTED
-# define STATUS_LPC_RECEIVE_BUFFER_EXPECTED ((NTSTATUS) 0xC0000705L)
-#endif
-
-#ifndef STATUS_LPC_INVALID_CONNECTION_USAGE
-# define STATUS_LPC_INVALID_CONNECTION_USAGE ((NTSTATUS) 0xC0000706L)
-#endif
-
-#ifndef STATUS_LPC_REQUESTS_NOT_ALLOWED
-# define STATUS_LPC_REQUESTS_NOT_ALLOWED ((NTSTATUS) 0xC0000707L)
-#endif
-
-#ifndef STATUS_RESOURCE_IN_USE
-# define STATUS_RESOURCE_IN_USE ((NTSTATUS) 0xC0000708L)
-#endif
-
-#ifndef STATUS_HARDWARE_MEMORY_ERROR
-# define STATUS_HARDWARE_MEMORY_ERROR ((NTSTATUS) 0xC0000709L)
-#endif
-
-#ifndef STATUS_THREADPOOL_HANDLE_EXCEPTION
-# define STATUS_THREADPOOL_HANDLE_EXCEPTION ((NTSTATUS) 0xC000070AL)
-#endif
-
-#ifndef STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED
-# define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED ((NTSTATUS) 0xC000070BL)
-#endif
-
-#ifndef STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED
-# define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED ((NTSTATUS) 0xC000070CL)
-#endif
-
-#ifndef STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED
-# define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED ((NTSTATUS) 0xC000070DL)
-#endif
-
-#ifndef STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED
-# define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED ((NTSTATUS) 0xC000070EL)
-#endif
-
-#ifndef STATUS_THREADPOOL_RELEASED_DURING_OPERATION
-# define STATUS_THREADPOOL_RELEASED_DURING_OPERATION ((NTSTATUS) 0xC000070FL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING
-# define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING ((NTSTATUS) 0xC0000710L)
-#endif
-
-#ifndef STATUS_APC_RETURNED_WHILE_IMPERSONATING
-# define STATUS_APC_RETURNED_WHILE_IMPERSONATING ((NTSTATUS) 0xC0000711L)
-#endif
-
-#ifndef STATUS_PROCESS_IS_PROTECTED
-# define STATUS_PROCESS_IS_PROTECTED ((NTSTATUS) 0xC0000712L)
-#endif
-
-#ifndef STATUS_MCA_EXCEPTION
-# define STATUS_MCA_EXCEPTION ((NTSTATUS) 0xC0000713L)
-#endif
-
-#ifndef STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE
-# define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE ((NTSTATUS) 0xC0000714L)
-#endif
-
-#ifndef STATUS_SYMLINK_CLASS_DISABLED
-# define STATUS_SYMLINK_CLASS_DISABLED ((NTSTATUS) 0xC0000715L)
-#endif
-
-#ifndef STATUS_INVALID_IDN_NORMALIZATION
-# define STATUS_INVALID_IDN_NORMALIZATION ((NTSTATUS) 0xC0000716L)
-#endif
-
-#ifndef STATUS_NO_UNICODE_TRANSLATION
-# define STATUS_NO_UNICODE_TRANSLATION ((NTSTATUS) 0xC0000717L)
-#endif
-
-#ifndef STATUS_ALREADY_REGISTERED
-# define STATUS_ALREADY_REGISTERED ((NTSTATUS) 0xC0000718L)
-#endif
-
-#ifndef STATUS_CONTEXT_MISMATCH
-# define STATUS_CONTEXT_MISMATCH ((NTSTATUS) 0xC0000719L)
-#endif
-
-#ifndef STATUS_PORT_ALREADY_HAS_COMPLETION_LIST
-# define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST ((NTSTATUS) 0xC000071AL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_THREAD_PRIORITY
-# define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY ((NTSTATUS) 0xC000071BL)
-#endif
-
-#ifndef STATUS_INVALID_THREAD
-# define STATUS_INVALID_THREAD ((NTSTATUS) 0xC000071CL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_TRANSACTION
-# define STATUS_CALLBACK_RETURNED_TRANSACTION ((NTSTATUS) 0xC000071DL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_LDR_LOCK
-# define STATUS_CALLBACK_RETURNED_LDR_LOCK ((NTSTATUS) 0xC000071EL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_LANG
-# define STATUS_CALLBACK_RETURNED_LANG ((NTSTATUS) 0xC000071FL)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_PRI_BACK
-# define STATUS_CALLBACK_RETURNED_PRI_BACK ((NTSTATUS) 0xC0000720L)
-#endif
-
-#ifndef STATUS_CALLBACK_RETURNED_THREAD_AFFINITY
-# define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY ((NTSTATUS) 0xC0000721L)
-#endif
-
-#ifndef STATUS_DISK_REPAIR_DISABLED
-# define STATUS_DISK_REPAIR_DISABLED ((NTSTATUS) 0xC0000800L)
-#endif
-
-#ifndef STATUS_DS_DOMAIN_RENAME_IN_PROGRESS
-# define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS ((NTSTATUS) 0xC0000801L)
-#endif
-
-#ifndef STATUS_DISK_QUOTA_EXCEEDED
-# define STATUS_DISK_QUOTA_EXCEEDED ((NTSTATUS) 0xC0000802L)
-#endif
-
-#ifndef STATUS_DATA_LOST_REPAIR
-# define STATUS_DATA_LOST_REPAIR ((NTSTATUS) 0x80000803L)
-#endif
-
-#ifndef STATUS_CONTENT_BLOCKED
-# define STATUS_CONTENT_BLOCKED ((NTSTATUS) 0xC0000804L)
-#endif
-
-#ifndef STATUS_BAD_CLUSTERS
-# define STATUS_BAD_CLUSTERS ((NTSTATUS) 0xC0000805L)
-#endif
-
-#ifndef STATUS_VOLUME_DIRTY
-# define STATUS_VOLUME_DIRTY ((NTSTATUS) 0xC0000806L)
-#endif
-
-#ifndef STATUS_FILE_CHECKED_OUT
-# define STATUS_FILE_CHECKED_OUT ((NTSTATUS) 0xC0000901L)
-#endif
-
-#ifndef STATUS_CHECKOUT_REQUIRED
-# define STATUS_CHECKOUT_REQUIRED ((NTSTATUS) 0xC0000902L)
-#endif
-
-#ifndef STATUS_BAD_FILE_TYPE
-# define STATUS_BAD_FILE_TYPE ((NTSTATUS) 0xC0000903L)
-#endif
-
-#ifndef STATUS_FILE_TOO_LARGE
-# define STATUS_FILE_TOO_LARGE ((NTSTATUS) 0xC0000904L)
-#endif
-
-#ifndef STATUS_FORMS_AUTH_REQUIRED
-# define STATUS_FORMS_AUTH_REQUIRED ((NTSTATUS) 0xC0000905L)
-#endif
-
-#ifndef STATUS_VIRUS_INFECTED
-# define STATUS_VIRUS_INFECTED ((NTSTATUS) 0xC0000906L)
-#endif
-
-#ifndef STATUS_VIRUS_DELETED
-# define STATUS_VIRUS_DELETED ((NTSTATUS) 0xC0000907L)
-#endif
-
-#ifndef STATUS_BAD_MCFG_TABLE
-# define STATUS_BAD_MCFG_TABLE ((NTSTATUS) 0xC0000908L)
-#endif
-
-#ifndef STATUS_CANNOT_BREAK_OPLOCK
-# define STATUS_CANNOT_BREAK_OPLOCK ((NTSTATUS) 0xC0000909L)
-#endif
-
-#ifndef STATUS_WOW_ASSERTION
-# define STATUS_WOW_ASSERTION ((NTSTATUS) 0xC0009898L)
-#endif
-
-#ifndef STATUS_INVALID_SIGNATURE
-# define STATUS_INVALID_SIGNATURE ((NTSTATUS) 0xC000A000L)
-#endif
-
-#ifndef STATUS_HMAC_NOT_SUPPORTED
-# define STATUS_HMAC_NOT_SUPPORTED ((NTSTATUS) 0xC000A001L)
-#endif
-
-#ifndef STATUS_AUTH_TAG_MISMATCH
-# define STATUS_AUTH_TAG_MISMATCH ((NTSTATUS) 0xC000A002L)
-#endif
-
-#ifndef STATUS_IPSEC_QUEUE_OVERFLOW
-# define STATUS_IPSEC_QUEUE_OVERFLOW ((NTSTATUS) 0xC000A010L)
-#endif
-
-#ifndef STATUS_ND_QUEUE_OVERFLOW
-# define STATUS_ND_QUEUE_OVERFLOW ((NTSTATUS) 0xC000A011L)
-#endif
-
-#ifndef STATUS_HOPLIMIT_EXCEEDED
-# define STATUS_HOPLIMIT_EXCEEDED ((NTSTATUS) 0xC000A012L)
-#endif
-
-#ifndef STATUS_PROTOCOL_NOT_SUPPORTED
-# define STATUS_PROTOCOL_NOT_SUPPORTED ((NTSTATUS) 0xC000A013L)
-#endif
-
-#ifndef STATUS_FASTPATH_REJECTED
-# define STATUS_FASTPATH_REJECTED ((NTSTATUS) 0xC000A014L)
-#endif
-
-#ifndef STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED
-# define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED ((NTSTATUS) 0xC000A080L)
-#endif
-
-#ifndef STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR
-# define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR ((NTSTATUS) 0xC000A081L)
-#endif
-
-#ifndef STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR
-# define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR ((NTSTATUS) 0xC000A082L)
-#endif
-
-#ifndef STATUS_XML_PARSE_ERROR
-# define STATUS_XML_PARSE_ERROR ((NTSTATUS) 0xC000A083L)
-#endif
-
-#ifndef STATUS_XMLDSIG_ERROR
-# define STATUS_XMLDSIG_ERROR ((NTSTATUS) 0xC000A084L)
-#endif
-
-#ifndef STATUS_WRONG_COMPARTMENT
-# define STATUS_WRONG_COMPARTMENT ((NTSTATUS) 0xC000A085L)
-#endif
-
-#ifndef STATUS_AUTHIP_FAILURE
-# define STATUS_AUTHIP_FAILURE ((NTSTATUS) 0xC000A086L)
-#endif
-
-#ifndef STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS
-# define STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS ((NTSTATUS) 0xC000A087L)
-#endif
-
-#ifndef STATUS_DS_OID_NOT_FOUND
-# define STATUS_DS_OID_NOT_FOUND ((NTSTATUS) 0xC000A088L)
-#endif
-
-#ifndef STATUS_HASH_NOT_SUPPORTED
-# define STATUS_HASH_NOT_SUPPORTED ((NTSTATUS) 0xC000A100L)
-#endif
-
-#ifndef STATUS_HASH_NOT_PRESENT
-# define STATUS_HASH_NOT_PRESENT ((NTSTATUS) 0xC000A101L)
-#endif
-
-/* This is not the NTSTATUS_FROM_WIN32 that the DDK provides, because the DDK
- * got it wrong! */
-#ifdef NTSTATUS_FROM_WIN32
-# undef NTSTATUS_FROM_WIN32
-#endif
-#define NTSTATUS_FROM_WIN32(error) ((NTSTATUS) (error) <= 0 ? \
-        ((NTSTATUS) (error)) : ((NTSTATUS) (((error) & 0x0000FFFF) | \
-        (FACILITY_NTWIN32 << 16) | ERROR_SEVERITY_WARNING)))
-
-#ifndef JOB_OBJECT_LIMIT_PROCESS_MEMORY
-# define JOB_OBJECT_LIMIT_PROCESS_MEMORY             0x00000100
-#endif
-#ifndef JOB_OBJECT_LIMIT_JOB_MEMORY
-# define JOB_OBJECT_LIMIT_JOB_MEMORY                 0x00000200
-#endif
-#ifndef JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION
-# define JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION 0x00000400
-#endif
-#ifndef JOB_OBJECT_LIMIT_BREAKAWAY_OK
-# define JOB_OBJECT_LIMIT_BREAKAWAY_OK               0x00000800
-#endif
-#ifndef JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK
-# define JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK        0x00001000
-#endif
-#ifndef JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
-# define JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE          0x00002000
-#endif
-
-#ifndef SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
-# define SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE 0x00000002
-#endif
-
-/* from winternl.h */
-#if !defined(__UNICODE_STRING_DEFINED) && defined(__MINGW32_)
-#define __UNICODE_STRING_DEFINED
-#endif
-typedef struct _UNICODE_STRING {
-  USHORT Length;
-  USHORT MaximumLength;
-  PWSTR  Buffer;
-} UNICODE_STRING, *PUNICODE_STRING;
-
-typedef const UNICODE_STRING *PCUNICODE_STRING;
-
-/* from ntifs.h */
-#ifndef DEVICE_TYPE
-# define DEVICE_TYPE DWORD
-#endif
-
-/* MinGW already has a definition for REPARSE_DATA_BUFFER, but mingw-w64 does
- * not.
- */
-#if defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR)
-  typedef struct _REPARSE_DATA_BUFFER {
-    ULONG  ReparseTag;
-    USHORT ReparseDataLength;
-    USHORT Reserved;
-    union {
-      struct {
-        USHORT SubstituteNameOffset;
-        USHORT SubstituteNameLength;
-        USHORT PrintNameOffset;
-        USHORT PrintNameLength;
-        ULONG Flags;
-        WCHAR PathBuffer[1];
-      } SymbolicLinkReparseBuffer;
-      struct {
-        USHORT SubstituteNameOffset;
-        USHORT SubstituteNameLength;
-        USHORT PrintNameOffset;
-        USHORT PrintNameLength;
-        WCHAR PathBuffer[1];
-      } MountPointReparseBuffer;
-      struct {
-        UCHAR  DataBuffer[1];
-      } GenericReparseBuffer;
-    };
-  } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
-#endif
-
-typedef struct _IO_STATUS_BLOCK {
-  union {
-    NTSTATUS Status;
-    PVOID Pointer;
-  };
-  ULONG_PTR Information;
-} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
-
-typedef enum _FILE_INFORMATION_CLASS {
-  FileDirectoryInformation = 1,
-  FileFullDirectoryInformation,
-  FileBothDirectoryInformation,
-  FileBasicInformation,
-  FileStandardInformation,
-  FileInternalInformation,
-  FileEaInformation,
-  FileAccessInformation,
-  FileNameInformation,
-  FileRenameInformation,
-  FileLinkInformation,
-  FileNamesInformation,
-  FileDispositionInformation,
-  FilePositionInformation,
-  FileFullEaInformation,
-  FileModeInformation,
-  FileAlignmentInformation,
-  FileAllInformation,
-  FileAllocationInformation,
-  FileEndOfFileInformation,
-  FileAlternateNameInformation,
-  FileStreamInformation,
-  FilePipeInformation,
-  FilePipeLocalInformation,
-  FilePipeRemoteInformation,
-  FileMailslotQueryInformation,
-  FileMailslotSetInformation,
-  FileCompressionInformation,
-  FileObjectIdInformation,
-  FileCompletionInformation,
-  FileMoveClusterInformation,
-  FileQuotaInformation,
-  FileReparsePointInformation,
-  FileNetworkOpenInformation,
-  FileAttributeTagInformation,
-  FileTrackingInformation,
-  FileIdBothDirectoryInformation,
-  FileIdFullDirectoryInformation,
-  FileValidDataLengthInformation,
-  FileShortNameInformation,
-  FileIoCompletionNotificationInformation,
-  FileIoStatusBlockRangeInformation,
-  FileIoPriorityHintInformation,
-  FileSfioReserveInformation,
-  FileSfioVolumeInformation,
-  FileHardLinkInformation,
-  FileProcessIdsUsingFileInformation,
-  FileNormalizedNameInformation,
-  FileNetworkPhysicalNameInformation,
-  FileIdGlobalTxDirectoryInformation,
-  FileIsRemoteDeviceInformation,
-  FileAttributeCacheInformation,
-  FileNumaNodeInformation,
-  FileStandardLinkInformation,
-  FileRemoteProtocolInformation,
-  FileMaximumInformation
-} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
-
-typedef struct _FILE_DIRECTORY_INFORMATION {
-  ULONG NextEntryOffset;
-  ULONG FileIndex;
-  LARGE_INTEGER CreationTime;
-  LARGE_INTEGER LastAccessTime;
-  LARGE_INTEGER LastWriteTime;
-  LARGE_INTEGER ChangeTime;
-  LARGE_INTEGER EndOfFile;
-  LARGE_INTEGER AllocationSize;
-  ULONG FileAttributes;
-  ULONG FileNameLength;
-  WCHAR FileName[1];
-} FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION;
-
-typedef struct _FILE_BOTH_DIR_INFORMATION {
-  ULONG NextEntryOffset;
-  ULONG FileIndex;
-  LARGE_INTEGER CreationTime;
-  LARGE_INTEGER LastAccessTime;
-  LARGE_INTEGER LastWriteTime;
-  LARGE_INTEGER ChangeTime;
-  LARGE_INTEGER EndOfFile;
-  LARGE_INTEGER AllocationSize;
-  ULONG FileAttributes;
-  ULONG FileNameLength;
-  ULONG EaSize;
-  CCHAR ShortNameLength;
-  WCHAR ShortName[12];
-  WCHAR FileName[1];
-} FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION;
-
-typedef struct _FILE_BASIC_INFORMATION {
-  LARGE_INTEGER CreationTime;
-  LARGE_INTEGER LastAccessTime;
-  LARGE_INTEGER LastWriteTime;
-  LARGE_INTEGER ChangeTime;
-  DWORD FileAttributes;
-} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
-
-typedef struct _FILE_STANDARD_INFORMATION {
-  LARGE_INTEGER AllocationSize;
-  LARGE_INTEGER EndOfFile;
-  ULONG         NumberOfLinks;
-  BOOLEAN       DeletePending;
-  BOOLEAN       Directory;
-} FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
-
-typedef struct _FILE_INTERNAL_INFORMATION {
-  LARGE_INTEGER IndexNumber;
-} FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION;
-
-typedef struct _FILE_EA_INFORMATION {
-  ULONG EaSize;
-} FILE_EA_INFORMATION, *PFILE_EA_INFORMATION;
-
-typedef struct _FILE_ACCESS_INFORMATION {
-  ACCESS_MASK AccessFlags;
-} FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION;
-
-typedef struct _FILE_POSITION_INFORMATION {
-  LARGE_INTEGER CurrentByteOffset;
-} FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
-
-typedef struct _FILE_MODE_INFORMATION {
-  ULONG Mode;
-} FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION;
-
-typedef struct _FILE_ALIGNMENT_INFORMATION {
-  ULONG AlignmentRequirement;
-} FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
-
-typedef struct _FILE_NAME_INFORMATION {
-  ULONG FileNameLength;
-  WCHAR FileName[1];
-} FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
-
-typedef struct _FILE_END_OF_FILE_INFORMATION {
-  LARGE_INTEGER  EndOfFile;
-} FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION;
-
-typedef struct _FILE_ALL_INFORMATION {
-  FILE_BASIC_INFORMATION     BasicInformation;
-  FILE_STANDARD_INFORMATION  StandardInformation;
-  FILE_INTERNAL_INFORMATION  InternalInformation;
-  FILE_EA_INFORMATION        EaInformation;
-  FILE_ACCESS_INFORMATION    AccessInformation;
-  FILE_POSITION_INFORMATION  PositionInformation;
-  FILE_MODE_INFORMATION      ModeInformation;
-  FILE_ALIGNMENT_INFORMATION AlignmentInformation;
-  FILE_NAME_INFORMATION      NameInformation;
-} FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION;
-
-typedef struct _FILE_DISPOSITION_INFORMATION {
-  BOOLEAN DeleteFile;
-} FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION;
-
-typedef struct _FILE_PIPE_LOCAL_INFORMATION {
-  ULONG NamedPipeType;
-  ULONG NamedPipeConfiguration;
-  ULONG MaximumInstances;
-  ULONG CurrentInstances;
-  ULONG InboundQuota;
-  ULONG ReadDataAvailable;
-  ULONG OutboundQuota;
-  ULONG WriteQuotaAvailable;
-  ULONG NamedPipeState;
-  ULONG NamedPipeEnd;
-} FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION;
-
-#define FILE_SYNCHRONOUS_IO_ALERT               0x00000010
-#define FILE_SYNCHRONOUS_IO_NONALERT            0x00000020
-
-typedef enum _FS_INFORMATION_CLASS {
-  FileFsVolumeInformation       = 1,
-  FileFsLabelInformation        = 2,
-  FileFsSizeInformation         = 3,
-  FileFsDeviceInformation       = 4,
-  FileFsAttributeInformation    = 5,
-  FileFsControlInformation      = 6,
-  FileFsFullSizeInformation     = 7,
-  FileFsObjectIdInformation     = 8,
-  FileFsDriverPathInformation   = 9,
-  FileFsVolumeFlagsInformation  = 10,
-  FileFsSectorSizeInformation   = 11
-} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
-
-typedef struct _FILE_FS_VOLUME_INFORMATION {
-  LARGE_INTEGER VolumeCreationTime;
-  ULONG         VolumeSerialNumber;
-  ULONG         VolumeLabelLength;
-  BOOLEAN       SupportsObjects;
-  WCHAR         VolumeLabel[1];
-} FILE_FS_VOLUME_INFORMATION, *PFILE_FS_VOLUME_INFORMATION;
-
-typedef struct _FILE_FS_LABEL_INFORMATION {
-  ULONG VolumeLabelLength;
-  WCHAR VolumeLabel[1];
-} FILE_FS_LABEL_INFORMATION, *PFILE_FS_LABEL_INFORMATION;
-
-typedef struct _FILE_FS_SIZE_INFORMATION {
-  LARGE_INTEGER TotalAllocationUnits;
-  LARGE_INTEGER AvailableAllocationUnits;
-  ULONG         SectorsPerAllocationUnit;
-  ULONG         BytesPerSector;
-} FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
-
-typedef struct _FILE_FS_DEVICE_INFORMATION {
-  DEVICE_TYPE DeviceType;
-  ULONG       Characteristics;
-} FILE_FS_DEVICE_INFORMATION, *PFILE_FS_DEVICE_INFORMATION;
-
-typedef struct _FILE_FS_ATTRIBUTE_INFORMATION {
-  ULONG FileSystemAttributes;
-  LONG  MaximumComponentNameLength;
-  ULONG FileSystemNameLength;
-  WCHAR FileSystemName[1];
-} FILE_FS_ATTRIBUTE_INFORMATION, *PFILE_FS_ATTRIBUTE_INFORMATION;
-
-typedef struct _FILE_FS_CONTROL_INFORMATION {
-  LARGE_INTEGER FreeSpaceStartFiltering;
-  LARGE_INTEGER FreeSpaceThreshold;
-  LARGE_INTEGER FreeSpaceStopFiltering;
-  LARGE_INTEGER DefaultQuotaThreshold;
-  LARGE_INTEGER DefaultQuotaLimit;
-  ULONG         FileSystemControlFlags;
-} FILE_FS_CONTROL_INFORMATION, *PFILE_FS_CONTROL_INFORMATION;
-
-typedef struct _FILE_FS_FULL_SIZE_INFORMATION {
-  LARGE_INTEGER TotalAllocationUnits;
-  LARGE_INTEGER CallerAvailableAllocationUnits;
-  LARGE_INTEGER ActualAvailableAllocationUnits;
-  ULONG         SectorsPerAllocationUnit;
-  ULONG         BytesPerSector;
-} FILE_FS_FULL_SIZE_INFORMATION, *PFILE_FS_FULL_SIZE_INFORMATION;
-
-typedef struct _FILE_FS_OBJECTID_INFORMATION {
-  UCHAR ObjectId[16];
-  UCHAR ExtendedInfo[48];
-} FILE_FS_OBJECTID_INFORMATION, *PFILE_FS_OBJECTID_INFORMATION;
-
-typedef struct _FILE_FS_DRIVER_PATH_INFORMATION {
-  BOOLEAN DriverInPath;
-  ULONG   DriverNameLength;
-  WCHAR   DriverName[1];
-} FILE_FS_DRIVER_PATH_INFORMATION, *PFILE_FS_DRIVER_PATH_INFORMATION;
-
-typedef struct _FILE_FS_VOLUME_FLAGS_INFORMATION {
-  ULONG Flags;
-} FILE_FS_VOLUME_FLAGS_INFORMATION, *PFILE_FS_VOLUME_FLAGS_INFORMATION;
-
-typedef struct _FILE_FS_SECTOR_SIZE_INFORMATION {
-  ULONG LogicalBytesPerSector;
-  ULONG PhysicalBytesPerSectorForAtomicity;
-  ULONG PhysicalBytesPerSectorForPerformance;
-  ULONG FileSystemEffectivePhysicalBytesPerSectorForAtomicity;
-  ULONG Flags;
-  ULONG ByteOffsetForSectorAlignment;
-  ULONG ByteOffsetForPartitionAlignment;
-} FILE_FS_SECTOR_SIZE_INFORMATION, *PFILE_FS_SECTOR_SIZE_INFORMATION;
-
-typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
-    LARGE_INTEGER IdleTime;
-    LARGE_INTEGER KernelTime;
-    LARGE_INTEGER UserTime;
-    LARGE_INTEGER DpcTime;
-    LARGE_INTEGER InterruptTime;
-    ULONG InterruptCount;
-} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
-
-#ifndef SystemProcessorPerformanceInformation
-# define SystemProcessorPerformanceInformation 8
-#endif
-
-#ifndef FILE_DEVICE_FILE_SYSTEM
-# define FILE_DEVICE_FILE_SYSTEM 0x00000009
-#endif
-
-#ifndef FILE_DEVICE_NETWORK
-# define FILE_DEVICE_NETWORK 0x00000012
-#endif
-
-#ifndef METHOD_BUFFERED
-# define METHOD_BUFFERED 0
-#endif
-
-#ifndef METHOD_IN_DIRECT
-# define METHOD_IN_DIRECT 1
-#endif
-
-#ifndef METHOD_OUT_DIRECT
-# define METHOD_OUT_DIRECT 2
-#endif
-
-#ifndef METHOD_NEITHER
-#define METHOD_NEITHER 3
-#endif
-
-#ifndef METHOD_DIRECT_TO_HARDWARE
-# define METHOD_DIRECT_TO_HARDWARE METHOD_IN_DIRECT
-#endif
-
-#ifndef METHOD_DIRECT_FROM_HARDWARE
-# define METHOD_DIRECT_FROM_HARDWARE METHOD_OUT_DIRECT
-#endif
-
-#ifndef FILE_ANY_ACCESS
-# define FILE_ANY_ACCESS 0
-#endif
-
-#ifndef FILE_SPECIAL_ACCESS
-# define FILE_SPECIAL_ACCESS (FILE_ANY_ACCESS)
-#endif
-
-#ifndef FILE_READ_ACCESS
-# define FILE_READ_ACCESS 0x0001
-#endif
-
-#ifndef FILE_WRITE_ACCESS
-# define FILE_WRITE_ACCESS 0x0002
-#endif
-
-#ifndef CTL_CODE
-# define CTL_CODE(device_type, function, method, access)                      \
-    (((device_type) << 16) | ((access) << 14) | ((function) << 2) | (method))
-#endif
-
-#ifndef FSCTL_SET_REPARSE_POINT
-# define FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM,            \
-                                          41,                                 \
-                                          METHOD_BUFFERED,                    \
-                                          FILE_SPECIAL_ACCESS)
-#endif
-
-#ifndef FSCTL_GET_REPARSE_POINT
-# define FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM,            \
-                                          42,                                 \
-                                          METHOD_BUFFERED,                    \
-                                          FILE_ANY_ACCESS)
-#endif
-
-#ifndef FSCTL_DELETE_REPARSE_POINT
-# define FSCTL_DELETE_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM,         \
-                                             43,                              \
-                                             METHOD_BUFFERED,                 \
-                                             FILE_SPECIAL_ACCESS)
-#endif
-
-#ifndef IO_REPARSE_TAG_SYMLINK
-# define IO_REPARSE_TAG_SYMLINK (0xA000000CL)
-#endif
-
-typedef VOID (NTAPI *PIO_APC_ROUTINE)
-             (PVOID ApcContext,
-              PIO_STATUS_BLOCK IoStatusBlock,
-              ULONG Reserved);
-
-typedef NTSTATUS (NTAPI *sRtlGetVersion)
-                 (PRTL_OSVERSIONINFOW lpVersionInformation);
-
-typedef ULONG (NTAPI *sRtlNtStatusToDosError)
-              (NTSTATUS Status);
-
-typedef NTSTATUS (NTAPI *sNtDeviceIoControlFile)
-                 (HANDLE FileHandle,
-                  HANDLE Event,
-                  PIO_APC_ROUTINE ApcRoutine,
-                  PVOID ApcContext,
-                  PIO_STATUS_BLOCK IoStatusBlock,
-                  ULONG IoControlCode,
-                  PVOID InputBuffer,
-                  ULONG InputBufferLength,
-                  PVOID OutputBuffer,
-                  ULONG OutputBufferLength);
-
-typedef NTSTATUS (NTAPI *sNtQueryInformationFile)
-                 (HANDLE FileHandle,
-                  PIO_STATUS_BLOCK IoStatusBlock,
-                  PVOID FileInformation,
-                  ULONG Length,
-                  FILE_INFORMATION_CLASS FileInformationClass);
-
-typedef NTSTATUS (NTAPI *sNtSetInformationFile)
-                 (HANDLE FileHandle,
-                  PIO_STATUS_BLOCK IoStatusBlock,
-                  PVOID FileInformation,
-                  ULONG Length,
-                  FILE_INFORMATION_CLASS FileInformationClass);
-
-typedef NTSTATUS (NTAPI *sNtQueryVolumeInformationFile)
-                 (HANDLE FileHandle,
-                  PIO_STATUS_BLOCK IoStatusBlock,
-                  PVOID FsInformation,
-                  ULONG Length,
-                  FS_INFORMATION_CLASS FsInformationClass);
-
-typedef NTSTATUS (NTAPI *sNtQuerySystemInformation)
-                 (UINT SystemInformationClass,
-                  PVOID SystemInformation,
-                  ULONG SystemInformationLength,
-                  PULONG ReturnLength);
-
-typedef NTSTATUS (NTAPI *sNtQueryDirectoryFile)
-                 (HANDLE FileHandle,
-                  HANDLE Event,
-                  PIO_APC_ROUTINE ApcRoutine,
-                  PVOID ApcContext,
-                  PIO_STATUS_BLOCK IoStatusBlock,
-                  PVOID FileInformation,
-                  ULONG Length,
-                  FILE_INFORMATION_CLASS FileInformationClass,
-                  BOOLEAN ReturnSingleEntry,
-                  PUNICODE_STRING FileName,
-                  BOOLEAN RestartScan
-                );
-
-/*
- * Kernel32 headers
- */
-#ifndef FILE_SKIP_COMPLETION_PORT_ON_SUCCESS
-# define FILE_SKIP_COMPLETION_PORT_ON_SUCCESS 0x1
-#endif
-
-#ifndef FILE_SKIP_SET_EVENT_ON_HANDLE
-# define FILE_SKIP_SET_EVENT_ON_HANDLE 0x2
-#endif
-
-#ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
-# define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
-#endif
-
-#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
-  typedef struct _OVERLAPPED_ENTRY {
-      ULONG_PTR lpCompletionKey;
-      LPOVERLAPPED lpOverlapped;
-      ULONG_PTR Internal;
-      DWORD dwNumberOfBytesTransferred;
-  } OVERLAPPED_ENTRY, *LPOVERLAPPED_ENTRY;
-#endif
-
-/* from wincon.h */
-#ifndef ENABLE_INSERT_MODE
-# define ENABLE_INSERT_MODE 0x20
-#endif
-
-#ifndef ENABLE_QUICK_EDIT_MODE
-# define ENABLE_QUICK_EDIT_MODE 0x40
-#endif
-
-#ifndef ENABLE_EXTENDED_FLAGS
-# define ENABLE_EXTENDED_FLAGS 0x80
-#endif
-
-/* from winerror.h */
-#ifndef ERROR_ELEVATION_REQUIRED
-# define ERROR_ELEVATION_REQUIRED 740
-#endif
-
-#ifndef ERROR_SYMLINK_NOT_SUPPORTED
-# define ERROR_SYMLINK_NOT_SUPPORTED 1464
-#endif
-
-#ifndef ERROR_MUI_FILE_NOT_FOUND
-# define ERROR_MUI_FILE_NOT_FOUND 15100
-#endif
-
-#ifndef ERROR_MUI_INVALID_FILE
-# define ERROR_MUI_INVALID_FILE 15101
-#endif
-
-#ifndef ERROR_MUI_INVALID_RC_CONFIG
-# define ERROR_MUI_INVALID_RC_CONFIG 15102
-#endif
-
-#ifndef ERROR_MUI_INVALID_LOCALE_NAME
-# define ERROR_MUI_INVALID_LOCALE_NAME 15103
-#endif
-
-#ifndef ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME
-# define ERROR_MUI_INVALID_ULTIMATEFALLBACK_NAME 15104
-#endif
-
-#ifndef ERROR_MUI_FILE_NOT_LOADED
-# define ERROR_MUI_FILE_NOT_LOADED 15105
-#endif
-
-typedef BOOL (WINAPI *sGetQueuedCompletionStatusEx)
-             (HANDLE CompletionPort,
-              LPOVERLAPPED_ENTRY lpCompletionPortEntries,
-              ULONG ulCount,
-              PULONG ulNumEntriesRemoved,
-              DWORD dwMilliseconds,
-              BOOL fAlertable);
-
-/* from powerbase.h */
-#ifndef DEVICE_NOTIFY_CALLBACK
-# define DEVICE_NOTIFY_CALLBACK 2
-#endif
-
-#ifndef PBT_APMRESUMEAUTOMATIC
-# define PBT_APMRESUMEAUTOMATIC 18
-#endif
-
-#ifndef PBT_APMRESUMESUSPEND
-# define PBT_APMRESUMESUSPEND 7
-#endif
-
-typedef ULONG CALLBACK _DEVICE_NOTIFY_CALLBACK_ROUTINE(
-  PVOID Context,
-  ULONG Type,
-  PVOID Setting
-);
-typedef _DEVICE_NOTIFY_CALLBACK_ROUTINE* _PDEVICE_NOTIFY_CALLBACK_ROUTINE;
-
-typedef struct _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS {
-  _PDEVICE_NOTIFY_CALLBACK_ROUTINE Callback;
-  PVOID Context;
-} _DEVICE_NOTIFY_SUBSCRIBE_PARAMETERS, *_PDEVICE_NOTIFY_SUBSCRIBE_PARAMETERS;
-
-typedef PVOID _HPOWERNOTIFY;
-typedef _HPOWERNOTIFY *_PHPOWERNOTIFY;
-
-typedef DWORD (WINAPI *sPowerRegisterSuspendResumeNotification)
-              (DWORD         Flags,
-               HANDLE        Recipient,
-               _PHPOWERNOTIFY RegistrationHandle);
-
-/* from Winuser.h */
-typedef VOID (CALLBACK* WINEVENTPROC)
-             (HWINEVENTHOOK hWinEventHook,
-              DWORD         event,
-              HWND          hwnd,
-              LONG          idObject,
-              LONG          idChild,
-              DWORD         idEventThread,
-              DWORD         dwmsEventTime);
-
-typedef HWINEVENTHOOK (WINAPI *sSetWinEventHook)
-                      (UINT         eventMin,
-                       UINT         eventMax,
-                       HMODULE      hmodWinEventProc,
-                       WINEVENTPROC lpfnWinEventProc,
-                       DWORD        idProcess,
-                       DWORD        idThread,
-                       UINT         dwflags);
-
-
-/* Ntdll function pointers */
-extern sRtlGetVersion pRtlGetVersion;
-extern sRtlNtStatusToDosError pRtlNtStatusToDosError;
-extern sNtDeviceIoControlFile pNtDeviceIoControlFile;
-extern sNtQueryInformationFile pNtQueryInformationFile;
-extern sNtSetInformationFile pNtSetInformationFile;
-extern sNtQueryVolumeInformationFile pNtQueryVolumeInformationFile;
-extern sNtQueryDirectoryFile pNtQueryDirectoryFile;
-extern sNtQuerySystemInformation pNtQuerySystemInformation;
-
-/* Kernel32 function pointers */
-extern sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx;
-
-/* Powrprof.dll function pointer */
-extern sPowerRegisterSuspendResumeNotification pPowerRegisterSuspendResumeNotification;
-
-/* User32.dll function pointer */
-extern sSetWinEventHook pSetWinEventHook;
-
-#endif /* UV_WIN_WINAPI_H_ */
diff --git a/wpiutil/src/main/native/libuv/src/win/winsock.cpp b/wpiutil/src/main/native/libuv/src/win/winsock.cpp
deleted file mode 100644
index 668e3b6..0000000
--- a/wpiutil/src/main/native/libuv/src/win/winsock.cpp
+++ /dev/null
@@ -1,596 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 <assert.h>
-#include <stdlib.h>
-
-#include "uv.h"
-#include "internal.h"
-
-
-#pragma comment(lib, "Ws2_32.lib")
-
-/* Whether there are any non-IFS LSPs stacked on TCP */
-int uv_tcp_non_ifs_lsp_ipv4;
-int uv_tcp_non_ifs_lsp_ipv6;
-
-/* Ip address used to bind to any port at any interface */
-struct sockaddr_in uv_addr_ip4_any_;
-struct sockaddr_in6 uv_addr_ip6_any_;
-
-
-/*
- * Retrieves the pointer to a winsock extension function.
- */
-static BOOL uv_get_extension_function(SOCKET socket, GUID guid,
-    void **target) {
-  int result;
-  DWORD bytes;
-
-  result = WSAIoctl(socket,
-                    SIO_GET_EXTENSION_FUNCTION_POINTER,
-                    &guid,
-                    sizeof(guid),
-                    (void*)target,
-                    sizeof(*target),
-                    &bytes,
-                    NULL,
-                    NULL);
-
-  if (result == SOCKET_ERROR) {
-    *target = NULL;
-    return FALSE;
-  } else {
-    return TRUE;
-  }
-}
-
-
-BOOL uv_get_acceptex_function(SOCKET socket, LPFN_ACCEPTEX* target) {
-  const GUID wsaid_acceptex = WSAID_ACCEPTEX;
-  return uv_get_extension_function(socket, wsaid_acceptex, (void**)target);
-}
-
-
-BOOL uv_get_connectex_function(SOCKET socket, LPFN_CONNECTEX* target) {
-  const GUID wsaid_connectex = WSAID_CONNECTEX;
-  return uv_get_extension_function(socket, wsaid_connectex, (void**)target);
-}
-
-
-static int error_means_no_support(DWORD error) {
-  return error == WSAEPROTONOSUPPORT || error == WSAESOCKTNOSUPPORT ||
-         error == WSAEPFNOSUPPORT || error == WSAEAFNOSUPPORT;
-}
-
-
-void uv_winsock_init(void) {
-  WSADATA wsa_data;
-  int errorno;
-  SOCKET dummy;
-  WSAPROTOCOL_INFOW protocol_info;
-  int opt_len;
-
-  /* Set implicit binding address used by connectEx */
-  if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) {
-    abort();
-  }
-
-  if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) {
-    abort();
-  }
-
-  /* Skip initialization in safe mode without network support */
-  if (1 == GetSystemMetrics(SM_CLEANBOOT)) return;
-
-  /* Initialize winsock */
-  errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
-  if (errorno != 0) {
-    uv_fatal_error(errorno, "WSAStartup");
-  }
-
-  /* Detect non-IFS LSPs */
-  dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
-
-  if (dummy != INVALID_SOCKET) {
-    opt_len = (int) sizeof protocol_info;
-    if (getsockopt(dummy,
-                   SOL_SOCKET,
-                   SO_PROTOCOL_INFOW,
-                   (char*) &protocol_info,
-                   &opt_len) == SOCKET_ERROR)
-      uv_fatal_error(WSAGetLastError(), "getsockopt");
-
-    if (!(protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES))
-      uv_tcp_non_ifs_lsp_ipv4 = 1;
-
-    if (closesocket(dummy) == SOCKET_ERROR)
-      uv_fatal_error(WSAGetLastError(), "closesocket");
-
-  } else if (!error_means_no_support(WSAGetLastError())) {
-    /* Any error other than "socket type not supported" is fatal. */
-    uv_fatal_error(WSAGetLastError(), "socket");
-  }
-
-  /* Detect IPV6 support and non-IFS LSPs */
-  dummy = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
-
-  if (dummy != INVALID_SOCKET) {
-    opt_len = (int) sizeof protocol_info;
-    if (getsockopt(dummy,
-                   SOL_SOCKET,
-                   SO_PROTOCOL_INFOW,
-                   (char*) &protocol_info,
-                   &opt_len) == SOCKET_ERROR)
-      uv_fatal_error(WSAGetLastError(), "getsockopt");
-
-    if (!(protocol_info.dwServiceFlags1 & XP1_IFS_HANDLES))
-      uv_tcp_non_ifs_lsp_ipv6 = 1;
-
-    if (closesocket(dummy) == SOCKET_ERROR)
-      uv_fatal_error(WSAGetLastError(), "closesocket");
-
-  } else if (!error_means_no_support(WSAGetLastError())) {
-    /* Any error other than "socket type not supported" is fatal. */
-    uv_fatal_error(WSAGetLastError(), "socket");
-  }
-}
-
-
-int uv_ntstatus_to_winsock_error(NTSTATUS status) {
-  switch (status) {
-    case STATUS_SUCCESS:
-      return ERROR_SUCCESS;
-
-    case STATUS_PENDING:
-      return ERROR_IO_PENDING;
-
-    case STATUS_INVALID_HANDLE:
-    case STATUS_OBJECT_TYPE_MISMATCH:
-      return WSAENOTSOCK;
-
-    case STATUS_INSUFFICIENT_RESOURCES:
-    case STATUS_PAGEFILE_QUOTA:
-    case STATUS_COMMITMENT_LIMIT:
-    case STATUS_WORKING_SET_QUOTA:
-    case STATUS_NO_MEMORY:
-    case STATUS_QUOTA_EXCEEDED:
-    case STATUS_TOO_MANY_PAGING_FILES:
-    case STATUS_REMOTE_RESOURCES:
-      return WSAENOBUFS;
-
-    case STATUS_TOO_MANY_ADDRESSES:
-    case STATUS_SHARING_VIOLATION:
-    case STATUS_ADDRESS_ALREADY_EXISTS:
-      return WSAEADDRINUSE;
-
-    case STATUS_LINK_TIMEOUT:
-    case STATUS_IO_TIMEOUT:
-    case STATUS_TIMEOUT:
-      return WSAETIMEDOUT;
-
-    case STATUS_GRACEFUL_DISCONNECT:
-      return WSAEDISCON;
-
-    case STATUS_REMOTE_DISCONNECT:
-    case STATUS_CONNECTION_RESET:
-    case STATUS_LINK_FAILED:
-    case STATUS_CONNECTION_DISCONNECTED:
-    case STATUS_PORT_UNREACHABLE:
-    case STATUS_HOPLIMIT_EXCEEDED:
-      return WSAECONNRESET;
-
-    case STATUS_LOCAL_DISCONNECT:
-    case STATUS_TRANSACTION_ABORTED:
-    case STATUS_CONNECTION_ABORTED:
-      return WSAECONNABORTED;
-
-    case STATUS_BAD_NETWORK_PATH:
-    case STATUS_NETWORK_UNREACHABLE:
-    case STATUS_PROTOCOL_UNREACHABLE:
-      return WSAENETUNREACH;
-
-    case STATUS_HOST_UNREACHABLE:
-      return WSAEHOSTUNREACH;
-
-    case STATUS_CANCELLED:
-    case STATUS_REQUEST_ABORTED:
-      return WSAEINTR;
-
-    case STATUS_BUFFER_OVERFLOW:
-    case STATUS_INVALID_BUFFER_SIZE:
-      return WSAEMSGSIZE;
-
-    case STATUS_BUFFER_TOO_SMALL:
-    case STATUS_ACCESS_VIOLATION:
-      return WSAEFAULT;
-
-    case STATUS_DEVICE_NOT_READY:
-    case STATUS_REQUEST_NOT_ACCEPTED:
-      return WSAEWOULDBLOCK;
-
-    case STATUS_INVALID_NETWORK_RESPONSE:
-    case STATUS_NETWORK_BUSY:
-    case STATUS_NO_SUCH_DEVICE:
-    case STATUS_NO_SUCH_FILE:
-    case STATUS_OBJECT_PATH_NOT_FOUND:
-    case STATUS_OBJECT_NAME_NOT_FOUND:
-    case STATUS_UNEXPECTED_NETWORK_ERROR:
-      return WSAENETDOWN;
-
-    case STATUS_INVALID_CONNECTION:
-      return WSAENOTCONN;
-
-    case STATUS_REMOTE_NOT_LISTENING:
-    case STATUS_CONNECTION_REFUSED:
-      return WSAECONNREFUSED;
-
-    case STATUS_PIPE_DISCONNECTED:
-      return WSAESHUTDOWN;
-
-    case STATUS_CONFLICTING_ADDRESSES:
-    case STATUS_INVALID_ADDRESS:
-    case STATUS_INVALID_ADDRESS_COMPONENT:
-      return WSAEADDRNOTAVAIL;
-
-    case STATUS_NOT_SUPPORTED:
-    case STATUS_NOT_IMPLEMENTED:
-      return WSAEOPNOTSUPP;
-
-    case STATUS_ACCESS_DENIED:
-      return WSAEACCES;
-
-    default:
-      if ((status & (FACILITY_NTWIN32 << 16)) == (FACILITY_NTWIN32 << 16) &&
-          (status & (ERROR_SEVERITY_ERROR | ERROR_SEVERITY_WARNING))) {
-        /* It's a windows error that has been previously mapped to an ntstatus
-         * code. */
-        return (DWORD) (status & 0xffff);
-      } else {
-        /* The default fallback for unmappable ntstatus codes. */
-        return WSAEINVAL;
-      }
-  }
-}
-
-
-/*
- * This function provides a workaround for a bug in the winsock implementation
- * of WSARecv. The problem is that when SetFileCompletionNotificationModes is
- * used to avoid IOCP notifications of completed reads, WSARecv does not
- * reliably indicate whether we can expect a completion package to be posted
- * when the receive buffer is smaller than the received datagram.
- *
- * However it is desirable to use SetFileCompletionNotificationModes because
- * it yields a massive performance increase.
- *
- * This function provides a workaround for that bug, but it only works for the
- * specific case that we need it for. E.g. it assumes that the "avoid iocp"
- * bit has been set, and supports only overlapped operation. It also requires
- * the user to use the default msafd driver, doesn't work when other LSPs are
- * stacked on top of it.
- */
-int WSAAPI uv_wsarecv_workaround(SOCKET socket, WSABUF* buffers,
-    DWORD buffer_count, DWORD* bytes, DWORD* flags, WSAOVERLAPPED *overlapped,
-    LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine) {
-  NTSTATUS status;
-  void* apc_context;
-  IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
-  AFD_RECV_INFO info;
-  DWORD error;
-
-  if (overlapped == NULL || completion_routine != NULL) {
-    WSASetLastError(WSAEINVAL);
-    return SOCKET_ERROR;
-  }
-
-  info.BufferArray = buffers;
-  info.BufferCount = buffer_count;
-  info.AfdFlags = AFD_OVERLAPPED;
-  info.TdiFlags = TDI_RECEIVE_NORMAL;
-
-  if (*flags & MSG_PEEK) {
-    info.TdiFlags |= TDI_RECEIVE_PEEK;
-  }
-
-  if (*flags & MSG_PARTIAL) {
-    info.TdiFlags |= TDI_RECEIVE_PARTIAL;
-  }
-
-  if (!((intptr_t) overlapped->hEvent & 1)) {
-    apc_context = (void*) overlapped;
-  } else {
-    apc_context = NULL;
-  }
-
-  iosb->Status = STATUS_PENDING;
-  iosb->Pointer = 0;
-
-  status = pNtDeviceIoControlFile((HANDLE) socket,
-                                  overlapped->hEvent,
-                                  NULL,
-                                  apc_context,
-                                  iosb,
-                                  IOCTL_AFD_RECEIVE,
-                                  &info,
-                                  sizeof(info),
-                                  NULL,
-                                  0);
-
-  *flags = 0;
-  *bytes = (DWORD) iosb->Information;
-
-  switch (status) {
-    case STATUS_SUCCESS:
-      error = ERROR_SUCCESS;
-      break;
-
-    case STATUS_PENDING:
-      error = WSA_IO_PENDING;
-      break;
-
-    case STATUS_BUFFER_OVERFLOW:
-      error = WSAEMSGSIZE;
-      break;
-
-    case STATUS_RECEIVE_EXPEDITED:
-      error = ERROR_SUCCESS;
-      *flags = MSG_OOB;
-      break;
-
-    case STATUS_RECEIVE_PARTIAL_EXPEDITED:
-      error = ERROR_SUCCESS;
-      *flags = MSG_PARTIAL | MSG_OOB;
-      break;
-
-    case STATUS_RECEIVE_PARTIAL:
-      error = ERROR_SUCCESS;
-      *flags = MSG_PARTIAL;
-      break;
-
-    default:
-      error = uv_ntstatus_to_winsock_error(status);
-      break;
-  }
-
-  WSASetLastError(error);
-
-  if (error == ERROR_SUCCESS) {
-    return 0;
-  } else {
-    return SOCKET_ERROR;
-  }
-}
-
-
-/* See description of uv_wsarecv_workaround. */
-int WSAAPI uv_wsarecvfrom_workaround(SOCKET socket, WSABUF* buffers,
-    DWORD buffer_count, DWORD* bytes, DWORD* flags, struct sockaddr* addr,
-    int* addr_len, WSAOVERLAPPED *overlapped,
-    LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine) {
-  NTSTATUS status;
-  void* apc_context;
-  IO_STATUS_BLOCK* iosb = (IO_STATUS_BLOCK*) &overlapped->Internal;
-  AFD_RECV_DATAGRAM_INFO info;
-  DWORD error;
-
-  if (overlapped == NULL || addr == NULL || addr_len == NULL ||
-      completion_routine != NULL) {
-    WSASetLastError(WSAEINVAL);
-    return SOCKET_ERROR;
-  }
-
-  info.BufferArray = buffers;
-  info.BufferCount = buffer_count;
-  info.AfdFlags = AFD_OVERLAPPED;
-  info.TdiFlags = TDI_RECEIVE_NORMAL;
-  info.Address = addr;
-  info.AddressLength = addr_len;
-
-  if (*flags & MSG_PEEK) {
-    info.TdiFlags |= TDI_RECEIVE_PEEK;
-  }
-
-  if (*flags & MSG_PARTIAL) {
-    info.TdiFlags |= TDI_RECEIVE_PARTIAL;
-  }
-
-  if (!((intptr_t) overlapped->hEvent & 1)) {
-    apc_context = (void*) overlapped;
-  } else {
-    apc_context = NULL;
-  }
-
-  iosb->Status = STATUS_PENDING;
-  iosb->Pointer = 0;
-
-  status = pNtDeviceIoControlFile((HANDLE) socket,
-                                  overlapped->hEvent,
-                                  NULL,
-                                  apc_context,
-                                  iosb,
-                                  IOCTL_AFD_RECEIVE_DATAGRAM,
-                                  &info,
-                                  sizeof(info),
-                                  NULL,
-                                  0);
-
-  *flags = 0;
-  *bytes = (DWORD) iosb->Information;
-
-  switch (status) {
-    case STATUS_SUCCESS:
-      error = ERROR_SUCCESS;
-      break;
-
-    case STATUS_PENDING:
-      error = WSA_IO_PENDING;
-      break;
-
-    case STATUS_BUFFER_OVERFLOW:
-      error = WSAEMSGSIZE;
-      break;
-
-    case STATUS_RECEIVE_EXPEDITED:
-      error = ERROR_SUCCESS;
-      *flags = MSG_OOB;
-      break;
-
-    case STATUS_RECEIVE_PARTIAL_EXPEDITED:
-      error = ERROR_SUCCESS;
-      *flags = MSG_PARTIAL | MSG_OOB;
-      break;
-
-    case STATUS_RECEIVE_PARTIAL:
-      error = ERROR_SUCCESS;
-      *flags = MSG_PARTIAL;
-      break;
-
-    default:
-      error = uv_ntstatus_to_winsock_error(status);
-      break;
-  }
-
-  WSASetLastError(error);
-
-  if (error == ERROR_SUCCESS) {
-    return 0;
-  } else {
-    return SOCKET_ERROR;
-  }
-}
-
-
-int WSAAPI uv_msafd_poll(SOCKET socket, AFD_POLL_INFO* info_in,
-    AFD_POLL_INFO* info_out, OVERLAPPED* overlapped) {
-  IO_STATUS_BLOCK iosb;
-  IO_STATUS_BLOCK* iosb_ptr;
-  HANDLE event = NULL;
-  void* apc_context;
-  NTSTATUS status;
-  DWORD error;
-
-  if (overlapped != NULL) {
-    /* Overlapped operation. */
-    iosb_ptr = (IO_STATUS_BLOCK*) &overlapped->Internal;
-    event = overlapped->hEvent;
-
-    /* Do not report iocp completion if hEvent is tagged. */
-    if ((uintptr_t) event & 1) {
-      event = (HANDLE)((uintptr_t) event & ~(uintptr_t) 1);
-      apc_context = NULL;
-    } else {
-      apc_context = overlapped;
-    }
-
-  } else {
-    /* Blocking operation. */
-    iosb_ptr = &iosb;
-    event = CreateEvent(NULL, FALSE, FALSE, NULL);
-    if (event == NULL) {
-      return SOCKET_ERROR;
-    }
-    apc_context = NULL;
-  }
-
-  iosb_ptr->Status = STATUS_PENDING;
-  status = pNtDeviceIoControlFile((HANDLE) socket,
-                                  event,
-                                  NULL,
-                                  apc_context,
-                                  iosb_ptr,
-                                  IOCTL_AFD_POLL,
-                                  info_in,
-                                  sizeof *info_in,
-                                  info_out,
-                                  sizeof *info_out);
-
-  if (overlapped == NULL) {
-    /* If this is a blocking operation, wait for the event to become signaled,
-     * and then grab the real status from the io status block. */
-    if (status == STATUS_PENDING) {
-      DWORD r = WaitForSingleObject(event, INFINITE);
-
-      if (r == WAIT_FAILED) {
-        DWORD saved_error = GetLastError();
-        CloseHandle(event);
-        WSASetLastError(saved_error);
-        return SOCKET_ERROR;
-      }
-
-      status = iosb.Status;
-    }
-
-    CloseHandle(event);
-  }
-
-  switch (status) {
-    case STATUS_SUCCESS:
-      error = ERROR_SUCCESS;
-      break;
-
-    case STATUS_PENDING:
-      error = WSA_IO_PENDING;
-      break;
-
-    default:
-      error = uv_ntstatus_to_winsock_error(status);
-      break;
-  }
-
-  WSASetLastError(error);
-
-  if (error == ERROR_SUCCESS) {
-    return 0;
-  } else {
-    return SOCKET_ERROR;
-  }
-}
-
-int uv__convert_to_localhost_if_unspecified(const struct sockaddr* addr,
-                                            struct sockaddr_storage* storage) {
-  struct sockaddr_in* dest4;
-  struct sockaddr_in6* dest6;
-
-  if (addr == NULL)
-    return UV_EINVAL;
-
-  switch (addr->sa_family) {
-  case AF_INET:
-    dest4 = (struct sockaddr_in*) storage;
-    memcpy(dest4, addr, sizeof(*dest4));
-    if (dest4->sin_addr.s_addr == 0)
-      dest4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-    return 0;
-  case AF_INET6:
-    dest6 = (struct sockaddr_in6*) storage;
-    memcpy(dest6, addr, sizeof(*dest6));
-    if (memcmp(&dest6->sin6_addr,
-               &uv_addr_ip6_any_.sin6_addr,
-               sizeof(uv_addr_ip6_any_.sin6_addr)) == 0) {
-      struct in6_addr init_sin6_addr = IN6ADDR_LOOPBACK_INIT;
-      dest6->sin6_addr = init_sin6_addr;
-    }
-    return 0;
-  default:
-    return UV_EINVAL;
-  }
-}
diff --git a/wpiutil/src/main/native/libuv/src/win/winsock.h b/wpiutil/src/main/native/libuv/src/win/winsock.h
deleted file mode 100644
index 7ecb755..0000000
--- a/wpiutil/src/main/native/libuv/src/win/winsock.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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.
- */
-
-#ifndef UV_WIN_WINSOCK_H_
-#define UV_WIN_WINSOCK_H_
-
-#include <winsock2.h>
-#include <iptypes.h>
-#include <mswsock.h>
-#include <ws2tcpip.h>
-#include <windows.h>
-
-#include "winapi.h"
-
-
-/*
- * MinGW is missing these too
- */
-#ifndef SO_UPDATE_CONNECT_CONTEXT
-# define SO_UPDATE_CONNECT_CONTEXT 0x7010
-#endif
-
-#ifndef TCP_KEEPALIVE
-# define TCP_KEEPALIVE 3
-#endif
-
-#ifndef IPV6_V6ONLY
-# define IPV6_V6ONLY 27
-#endif
-
-#ifndef IPV6_HOPLIMIT
-# define IPV6_HOPLIMIT 21
-#endif
-
-#ifndef SIO_BASE_HANDLE
-# define SIO_BASE_HANDLE 0x48000022
-#endif
-
-/*
- * TDI defines that are only in the DDK.
- * We only need receive flags so far.
- */
-#ifndef TDI_RECEIVE_NORMAL
-  #define TDI_RECEIVE_BROADCAST           0x00000004
-  #define TDI_RECEIVE_MULTICAST           0x00000008
-  #define TDI_RECEIVE_PARTIAL             0x00000010
-  #define TDI_RECEIVE_NORMAL              0x00000020
-  #define TDI_RECEIVE_EXPEDITED           0x00000040
-  #define TDI_RECEIVE_PEEK                0x00000080
-  #define TDI_RECEIVE_NO_RESPONSE_EXP     0x00000100
-  #define TDI_RECEIVE_COPY_LOOKAHEAD      0x00000200
-  #define TDI_RECEIVE_ENTIRE_MESSAGE      0x00000400
-  #define TDI_RECEIVE_AT_DISPATCH_LEVEL   0x00000800
-  #define TDI_RECEIVE_CONTROL_INFO        0x00001000
-  #define TDI_RECEIVE_FORCE_INDICATION    0x00002000
-  #define TDI_RECEIVE_NO_PUSH             0x00004000
-#endif
-
-/*
- * The "Auxiliary Function Driver" is the windows kernel-mode driver that does
- * TCP, UDP etc. Winsock is just a layer that dispatches requests to it.
- * Having these definitions allows us to bypass winsock and make an AFD kernel
- * call directly, avoiding a bug in winsock's recvfrom implementation.
- */
-
-#define AFD_NO_FAST_IO   0x00000001
-#define AFD_OVERLAPPED   0x00000002
-#define AFD_IMMEDIATE    0x00000004
-
-#define AFD_POLL_RECEIVE_BIT            0
-#define AFD_POLL_RECEIVE                (1 << AFD_POLL_RECEIVE_BIT)
-#define AFD_POLL_RECEIVE_EXPEDITED_BIT  1
-#define AFD_POLL_RECEIVE_EXPEDITED      (1 << AFD_POLL_RECEIVE_EXPEDITED_BIT)
-#define AFD_POLL_SEND_BIT               2
-#define AFD_POLL_SEND                   (1 << AFD_POLL_SEND_BIT)
-#define AFD_POLL_DISCONNECT_BIT         3
-#define AFD_POLL_DISCONNECT             (1 << AFD_POLL_DISCONNECT_BIT)
-#define AFD_POLL_ABORT_BIT              4
-#define AFD_POLL_ABORT                  (1 << AFD_POLL_ABORT_BIT)
-#define AFD_POLL_LOCAL_CLOSE_BIT        5
-#define AFD_POLL_LOCAL_CLOSE            (1 << AFD_POLL_LOCAL_CLOSE_BIT)
-#define AFD_POLL_CONNECT_BIT            6
-#define AFD_POLL_CONNECT                (1 << AFD_POLL_CONNECT_BIT)
-#define AFD_POLL_ACCEPT_BIT             7
-#define AFD_POLL_ACCEPT                 (1 << AFD_POLL_ACCEPT_BIT)
-#define AFD_POLL_CONNECT_FAIL_BIT       8
-#define AFD_POLL_CONNECT_FAIL           (1 << AFD_POLL_CONNECT_FAIL_BIT)
-#define AFD_POLL_QOS_BIT                9
-#define AFD_POLL_QOS                    (1 << AFD_POLL_QOS_BIT)
-#define AFD_POLL_GROUP_QOS_BIT          10
-#define AFD_POLL_GROUP_QOS              (1 << AFD_POLL_GROUP_QOS_BIT)
-
-#define AFD_NUM_POLL_EVENTS             11
-#define AFD_POLL_ALL                    ((1 << AFD_NUM_POLL_EVENTS) - 1)
-
-typedef struct _AFD_RECV_DATAGRAM_INFO {
-    LPWSABUF BufferArray;
-    ULONG BufferCount;
-    ULONG AfdFlags;
-    ULONG TdiFlags;
-    struct sockaddr* Address;
-    int* AddressLength;
-} AFD_RECV_DATAGRAM_INFO, *PAFD_RECV_DATAGRAM_INFO;
-
-typedef struct _AFD_RECV_INFO {
-    LPWSABUF BufferArray;
-    ULONG BufferCount;
-    ULONG AfdFlags;
-    ULONG TdiFlags;
-} AFD_RECV_INFO, *PAFD_RECV_INFO;
-
-
-#define _AFD_CONTROL_CODE(operation, method) \
-    ((FSCTL_AFD_BASE) << 12 | (operation << 2) | method)
-
-#define FSCTL_AFD_BASE FILE_DEVICE_NETWORK
-
-#define AFD_RECEIVE            5
-#define AFD_RECEIVE_DATAGRAM   6
-#define AFD_POLL               9
-
-#define IOCTL_AFD_RECEIVE \
-    _AFD_CONTROL_CODE(AFD_RECEIVE, METHOD_NEITHER)
-
-#define IOCTL_AFD_RECEIVE_DATAGRAM \
-    _AFD_CONTROL_CODE(AFD_RECEIVE_DATAGRAM, METHOD_NEITHER)
-
-#define IOCTL_AFD_POLL \
-    _AFD_CONTROL_CODE(AFD_POLL, METHOD_BUFFERED)
-
-#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
-typedef struct _IP_ADAPTER_UNICAST_ADDRESS_XP {
-  /* FIXME: __C89_NAMELESS was removed */
-  /* __C89_NAMELESS */ union {
-    ULONGLONG Alignment;
-    /* __C89_NAMELESS */ struct {
-      ULONG Length;
-      DWORD Flags;
-    };
-  };
-  struct _IP_ADAPTER_UNICAST_ADDRESS_XP *Next;
-  SOCKET_ADDRESS Address;
-  IP_PREFIX_ORIGIN PrefixOrigin;
-  IP_SUFFIX_ORIGIN SuffixOrigin;
-  IP_DAD_STATE DadState;
-  ULONG ValidLifetime;
-  ULONG PreferredLifetime;
-  ULONG LeaseLifetime;
-} IP_ADAPTER_UNICAST_ADDRESS_XP,*PIP_ADAPTER_UNICAST_ADDRESS_XP;
-
-typedef struct _IP_ADAPTER_UNICAST_ADDRESS_LH {
-  union {
-    ULONGLONG Alignment;
-    struct {
-      ULONG Length;
-      DWORD Flags;
-    };
-  };
-  struct _IP_ADAPTER_UNICAST_ADDRESS_LH *Next;
-  SOCKET_ADDRESS Address;
-  IP_PREFIX_ORIGIN PrefixOrigin;
-  IP_SUFFIX_ORIGIN SuffixOrigin;
-  IP_DAD_STATE DadState;
-  ULONG ValidLifetime;
-  ULONG PreferredLifetime;
-  ULONG LeaseLifetime;
-  UINT8 OnLinkPrefixLength;
-} IP_ADAPTER_UNICAST_ADDRESS_LH,*PIP_ADAPTER_UNICAST_ADDRESS_LH;
-
-#endif
-
-int uv__convert_to_localhost_if_unspecified(const struct sockaddr* addr,
-                                            struct sockaddr_storage* storage);
-
-#endif /* UV_WIN_WINSOCK_H_ */
diff --git a/wpiutil/src/main/native/linux/AvahiClient.cpp b/wpiutil/src/main/native/linux/AvahiClient.cpp
deleted file mode 100644
index 6a17ea0..0000000
--- a/wpiutil/src/main/native/linux/AvahiClient.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "AvahiClient.h"
-
-#include <wpi/mutex.h>
-
-#include <thread>
-
-#include "dlfcn.h"
-
-using namespace wpi;
-
-#define AvahiFunctionLoad(snake_name)                                          \
-  do {                                                                         \
-    snake_name =                                                               \
-        reinterpret_cast<snake_name##_func>(dlsym(lib, "avahi_" #snake_name)); \
-    if (!snake_name) {                                                         \
-      return;                                                                  \
-    }                                                                          \
-  } while (false)
-
-AvahiFunctionTable::AvahiFunctionTable() {
-  void* lib = dlopen("libavahi-common.so.3", RTLD_LAZY);
-
-  valid = false;
-
-  if (lib == nullptr) {
-    return;
-  }
-
-  AvahiFunctionLoad(threaded_poll_new);
-  AvahiFunctionLoad(threaded_poll_free);
-  AvahiFunctionLoad(threaded_poll_get);
-  AvahiFunctionLoad(threaded_poll_start);
-  AvahiFunctionLoad(threaded_poll_stop);
-  AvahiFunctionLoad(threaded_poll_lock);
-  AvahiFunctionLoad(threaded_poll_unlock);
-  AvahiFunctionLoad(string_list_new_from_array);
-  AvahiFunctionLoad(string_list_free);
-  AvahiFunctionLoad(unescape_label);
-  AvahiFunctionLoad(alternative_service_name);
-  AvahiFunctionLoad(free);
-
-  lib = dlopen("libavahi-client.so.3", RTLD_LAZY);
-
-  if (lib == nullptr) {
-    return;
-  }
-
-  AvahiFunctionLoad(client_new);
-  AvahiFunctionLoad(client_free);
-  AvahiFunctionLoad(service_browser_new);
-  AvahiFunctionLoad(service_browser_get_client);
-  AvahiFunctionLoad(service_browser_free);
-  AvahiFunctionLoad(service_resolver_new);
-  AvahiFunctionLoad(service_resolver_free);
-  AvahiFunctionLoad(entry_group_new);
-  AvahiFunctionLoad(entry_group_free);
-  AvahiFunctionLoad(entry_group_add_service_strlst);
-  AvahiFunctionLoad(entry_group_reset);
-  AvahiFunctionLoad(entry_group_is_empty);
-  AvahiFunctionLoad(entry_group_commit);
-  AvahiFunctionLoad(entry_group_get_client);
-
-  valid = true;
-}
-
-AvahiFunctionTable& AvahiFunctionTable::Get() {
-  static AvahiFunctionTable table;
-  return table;
-}
-
-static wpi::mutex ThreadLoopLock;
-static std::weak_ptr<AvahiThread> ThreadLoop;
-
-std::shared_ptr<AvahiThread> AvahiThread::Get() {
-  std::scoped_lock lock{ThreadLoopLock};
-  auto locked = ThreadLoop.lock();
-  if (!locked) {
-    locked = std::make_unique<AvahiThread>(private_init{});
-    ThreadLoop = locked;
-  }
-  return locked;
-}
-
-AvahiThread::AvahiThread(const private_init&) {
-  if (!table.IsValid()) {
-    return;
-  }
-
-  threadedPoll = table.threaded_poll_new();
-  table.threaded_poll_start(threadedPoll);
-}
-
-AvahiThread::~AvahiThread() noexcept {
-  if (!table.IsValid()) {
-    return;
-  }
-
-  if (threadedPoll) {
-    table.threaded_poll_stop(threadedPoll);
-    table.threaded_poll_free(threadedPoll);
-  }
-}
-
-void AvahiThread::lock() {
-  table.threaded_poll_lock(threadedPoll);
-}
-
-void AvahiThread::unlock() {
-  table.threaded_poll_unlock(threadedPoll);
-}
-
-const AvahiPoll* AvahiThread::GetPoll() const {
-  return table.threaded_poll_get(threadedPoll);
-}
diff --git a/wpiutil/src/main/native/linux/AvahiClient.h b/wpiutil/src/main/native/linux/AvahiClient.h
deleted file mode 100644
index ca679bb..0000000
--- a/wpiutil/src/main/native/linux/AvahiClient.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <stdint.h>
-
-#include <memory>
-
-/***
-  This file is part of avahi.
-  avahi is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Lesser General Public License as
-  published by the Free Software Foundation; either version 2.1 of the
-  License, or (at your option) any later version.
-  avahi is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
-  Public License for more details.
-  You should have received a copy of the GNU Lesser General Public
-  License along with avahi; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-  USA.
-***/
-
-typedef struct AvahiPoll AvahiPoll;
-
-typedef enum {
-  AVAHI_SERVER_INVALID,
-  AVAHI_SERVER_REGISTERING,
-  AVAHI_SERVER_RUNNING,
-  AVAHI_SERVER_COLLISION,
-  AVAHI_SERVER_FAILURE
-} AvahiServerState;
-
-typedef struct AvahiClient AvahiClient;
-
-typedef enum {
-  AVAHI_CLIENT_S_REGISTERING = AVAHI_SERVER_REGISTERING,
-  AVAHI_CLIENT_S_RUNNING = AVAHI_SERVER_RUNNING,
-  AVAHI_CLIENT_S_COLLISION = AVAHI_SERVER_COLLISION,
-  AVAHI_CLIENT_FAILURE = 100,
-  AVAHI_CLIENT_CONNECTING = 101
-} AvahiClientState;
-
-typedef enum {
-  AVAHI_CLIENT_IGNORE_USER_CONFIG = 1,
-  AVAHI_CLIENT_NO_FAIL = 2
-} AvahiClientFlags;
-
-typedef void (*AvahiClientCallback)(AvahiClient* s, AvahiClientState state,
-                                    void* userdata);
-
-typedef struct AvahiServiceBrowser AvahiServiceBrowser;
-
-typedef int AvahiProtocol;
-
-typedef int AvahiIfIndex;
-
-typedef enum {
-  AVAHI_BROWSER_NEW,
-  AVAHI_BROWSER_REMOVE,
-  AVAHI_BROWSER_CACHE_EXHAUSTED,
-  AVAHI_BROWSER_ALL_FOR_NOW,
-  AVAHI_BROWSER_FAILURE
-} AvahiBrowserEvent;
-
-typedef enum {
-  AVAHI_LOOKUP_RESULT_CACHED = 1,
-  AVAHI_LOOKUP_RESULT_WIDE_AREA = 2,
-  AVAHI_LOOKUP_RESULT_MULTICAST = 4,
-  AVAHI_LOOKUP_RESULT_LOCAL = 8,
-  AVAHI_LOOKUP_RESULT_OUR_OWN = 16,
-  AVAHI_LOOKUP_RESULT_STATIC = 32
-} AvahiLookupResultFlags;
-
-typedef void (*AvahiServiceBrowserCallback)(
-    AvahiServiceBrowser* b, AvahiIfIndex interface, AvahiProtocol protocol,
-    AvahiBrowserEvent event, const char* name, const char* type,
-    const char* domain, AvahiLookupResultFlags flags, void* userdata);
-
-typedef enum {
-  AVAHI_LOOKUP_USE_WIDE_AREA = 1,
-  AVAHI_LOOKUP_USE_MULTICAST = 2,
-
-  AVAHI_LOOKUP_NO_TXT = 4,
-  AVAHI_LOOKUP_NO_ADDRESS = 8
-} AvahiLookupFlags;
-
-typedef struct AvahiServiceResolver AvahiServiceResolver;
-
-typedef enum {
-  AVAHI_RESOLVER_FOUND,
-  AVAHI_RESOLVER_FAILURE
-} AvahiResolverEvent;
-
-typedef struct AvahiIPv4Address {
-  uint32_t address;
-} AvahiIPv4Address;
-
-typedef struct AvahiIPv6Address {
-  uint8_t address[16];
-} AvahiIPv6Address;
-
-typedef struct AvahiAddress {
-  AvahiProtocol proto;
-
-  union {
-    AvahiIPv6Address ipv6;
-    AvahiIPv4Address ipv4;
-    uint8_t data[1];
-  } data;
-} AvahiAddress;
-
-typedef struct AvahiStringList {
-  struct AvahiStringList* next;
-  size_t size;
-  uint8_t text[1];
-} AvahiStringList;
-
-typedef void (*AvahiServiceResolverCallback)(
-    AvahiServiceResolver* r, AvahiIfIndex interface, AvahiProtocol protocol,
-    AvahiResolverEvent event, const char* name, const char* type,
-    const char* domain, const char* host_name, const AvahiAddress* a,
-    uint16_t port, AvahiStringList* txt, AvahiLookupResultFlags flags,
-    void* userdata);
-
-typedef struct AvahiThreadedPoll AvahiThreadedPoll;
-
-typedef struct AvahiEntryGroup AvahiEntryGroup;
-
-typedef enum {
-  AVAHI_ENTRY_GROUP_UNCOMMITED,
-  AVAHI_ENTRY_GROUP_REGISTERING,
-  AVAHI_ENTRY_GROUP_ESTABLISHED,
-  AVAHI_ENTRY_GROUP_COLLISION,
-  AVAHI_ENTRY_GROUP_FAILURE
-} AvahiEntryGroupState;
-
-typedef void (*AvahiEntryGroupCallback)(AvahiEntryGroup* g,
-                                        AvahiEntryGroupState state,
-                                        void* userdata);
-
-typedef enum {
-  AVAHI_PUBLISH_UNIQUE = 1,
-  AVAHI_PUBLISH_NO_PROBE = 2,
-  AVAHI_PUBLISH_NO_ANNOUNCE = 4,
-  AVAHI_PUBLISH_ALLOW_MULTIPLE = 8,
-
-  AVAHI_PUBLISH_NO_REVERSE = 16,
-  AVAHI_PUBLISH_NO_COOKIE = 32,
-  AVAHI_PUBLISH_UPDATE = 64,
-  AVAHI_PUBLISH_USE_WIDE_AREA = 128,
-  AVAHI_PUBLISH_USE_MULTICAST = 256
-} AvahiPublishFlags;
-
-enum { AVAHI_IF_UNSPEC = -1 };
-
-enum { AVAHI_PROTO_INET = 0, AVAHI_PROTO_INET6 = 1, AVAHI_PROTO_UNSPEC = -1 };
-
-enum {
-  AVAHI_OK = 0,
-  AVAHI_ERR_FAILURE = -1,
-  AVAHI_ERR_BAD_STATE = -2,
-  AVAHI_ERR_INVALID_HOST_NAME = -3,
-  AVAHI_ERR_INVALID_DOMAIN_NAME = -4,
-  AVAHI_ERR_NO_NETWORK = -5,
-  AVAHI_ERR_INVALID_TTL = -6,
-  AVAHI_ERR_IS_PATTERN = -7,
-  AVAHI_ERR_COLLISION = -8,
-  AVAHI_ERR_INVALID_RECORD = -9,
-
-  AVAHI_ERR_INVALID_SERVICE_NAME = -10,
-  AVAHI_ERR_INVALID_SERVICE_TYPE = -11,
-  AVAHI_ERR_INVALID_PORT = -12,
-  AVAHI_ERR_INVALID_KEY = -13,
-  AVAHI_ERR_INVALID_ADDRESS = -14,
-  AVAHI_ERR_TIMEOUT = -15,
-  AVAHI_ERR_TOO_MANY_CLIENTS = -16,
-  AVAHI_ERR_TOO_MANY_OBJECTS = -17,
-  AVAHI_ERR_TOO_MANY_ENTRIES = -18,
-  AVAHI_ERR_OS = -19,
-
-  AVAHI_ERR_ACCESS_DENIED = -20,
-  AVAHI_ERR_INVALID_OPERATION = -21,
-  AVAHI_ERR_DBUS_ERROR = -22,
-  AVAHI_ERR_DISCONNECTED = -23,
-  AVAHI_ERR_NO_MEMORY = -24,
-  AVAHI_ERR_INVALID_OBJECT = -25,
-  AVAHI_ERR_NO_DAEMON = -26,
-  AVAHI_ERR_INVALID_INTERFACE = -27,
-  AVAHI_ERR_INVALID_PROTOCOL = -28,
-  AVAHI_ERR_INVALID_FLAGS = -29,
-
-  AVAHI_ERR_NOT_FOUND = -30,
-  AVAHI_ERR_INVALID_CONFIG = -31,
-  AVAHI_ERR_VERSION_MISMATCH = -32,
-  AVAHI_ERR_INVALID_SERVICE_SUBTYPE = -33,
-  AVAHI_ERR_INVALID_PACKET = -34,
-  AVAHI_ERR_INVALID_DNS_ERROR = -35,
-  AVAHI_ERR_DNS_FORMERR = -36,
-  AVAHI_ERR_DNS_SERVFAIL = -37,
-  AVAHI_ERR_DNS_NXDOMAIN = -38,
-  AVAHI_ERR_DNS_NOTIMP = -39,
-
-  AVAHI_ERR_DNS_REFUSED = -40,
-  AVAHI_ERR_DNS_YXDOMAIN = -41,
-  AVAHI_ERR_DNS_YXRRSET = -42,
-  AVAHI_ERR_DNS_NXRRSET = -43,
-  AVAHI_ERR_DNS_NOTAUTH = -44,
-  AVAHI_ERR_DNS_NOTZONE = -45,
-  AVAHI_ERR_INVALID_RDATA = -46,
-  AVAHI_ERR_INVALID_DNS_CLASS = -47,
-  AVAHI_ERR_INVALID_DNS_TYPE = -48,
-  AVAHI_ERR_NOT_SUPPORTED = -49,
-
-  AVAHI_ERR_NOT_PERMITTED = -50,
-  AVAHI_ERR_INVALID_ARGUMENT = -51,
-  AVAHI_ERR_IS_EMPTY = -52,
-  AVAHI_ERR_NO_CHANGE = -53,
-
-  AVAHI_ERR_MAX = -54
-};
-
-namespace wpi {
-class AvahiFunctionTable {
- public:
-#define AvahiFunction(CapName, RetType, Parameters) \
-  using CapName##_func = RetType(*) Parameters;     \
-  CapName##_func CapName = nullptr
-
-  AvahiFunction(threaded_poll_new, AvahiThreadedPoll*, (void));
-  AvahiFunction(threaded_poll_free, void, (AvahiThreadedPoll*));
-  AvahiFunction(threaded_poll_get, const AvahiPoll*, (AvahiThreadedPoll*));
-  AvahiFunction(threaded_poll_start, int, (AvahiThreadedPoll*));
-  AvahiFunction(threaded_poll_stop, int, (AvahiThreadedPoll*));
-  AvahiFunction(threaded_poll_lock, int, (AvahiThreadedPoll*));
-  AvahiFunction(threaded_poll_unlock, int, (AvahiThreadedPoll*));
-
-  AvahiFunction(client_new, AvahiClient*,
-                (const AvahiPoll* poll_api, AvahiClientFlags flags,
-                 AvahiClientCallback callback, void* userdata, int* error));
-  AvahiFunction(client_free, void, (AvahiClient*));
-
-  AvahiFunction(service_browser_new, AvahiServiceBrowser*,
-                (AvahiClient * client, AvahiIfIndex interface,
-                 AvahiProtocol protocol, const char* type, const char* domain,
-                 AvahiLookupFlags flags, AvahiServiceBrowserCallback callback,
-                 void* userdata));
-
-  AvahiFunction(service_browser_free, int, (AvahiServiceBrowser*));
-
-  AvahiFunction(service_resolver_new, AvahiServiceResolver*,
-                (AvahiClient * client, AvahiIfIndex interface,
-                 AvahiProtocol protocol, const char* name, const char* type,
-                 const char* domain, AvahiProtocol aprotocol,
-                 AvahiLookupFlags flags, AvahiServiceResolverCallback callback,
-                 void* userdata));
-  AvahiFunction(service_resolver_free, int, (AvahiServiceResolver*));
-
-  AvahiFunction(entry_group_new, AvahiEntryGroup*,
-                (AvahiClient*, AvahiEntryGroupCallback, void*));
-  AvahiFunction(entry_group_free, int, (AvahiEntryGroup*));
-
-  AvahiFunction(entry_group_add_service_strlst, int,
-                (AvahiEntryGroup * group, AvahiIfIndex interface,
-                 AvahiProtocol protocol, AvahiPublishFlags flags,
-                 const char* name, const char* type, const char* domain,
-                 const char* host, uint16_t port, AvahiStringList*));
-
-  AvahiFunction(entry_group_reset, int, (AvahiEntryGroup*));
-  AvahiFunction(entry_group_is_empty, int, (AvahiEntryGroup*));
-  AvahiFunction(entry_group_commit, int, (AvahiEntryGroup*));
-  AvahiFunction(entry_group_get_client, AvahiClient*, (AvahiEntryGroup*));
-
-  AvahiFunction(string_list_new_from_array, AvahiStringList*,
-                (const char** array, int len));
-  AvahiFunction(string_list_free, void, (AvahiStringList*));
-
-  AvahiFunction(service_browser_get_client, AvahiClient*,
-                (AvahiServiceBrowser*));
-
-  AvahiFunction(unescape_label, char*, (const char**, char*, size_t));
-  AvahiFunction(alternative_service_name, char*, (const char*));
-  AvahiFunction(free, void, (void*));
-
-  bool IsValid() const { return valid; }
-
-  static AvahiFunctionTable& Get();
-
- private:
-  AvahiFunctionTable();
-  bool valid;
-};
-
-class AvahiThread {
- private:
-  struct private_init {};
-
- public:
-  explicit AvahiThread(const private_init&);
-  ~AvahiThread() noexcept;
-
-  void lock();
-  const AvahiPoll* GetPoll() const;
-  void unlock();
-
-  static std::shared_ptr<AvahiThread> Get();
-
- private:
-  AvahiThreadedPoll* threadedPoll;
-  AvahiFunctionTable& table = AvahiFunctionTable::Get();
-};
-
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/linux/MulticastServiceAnnouncer.cpp b/wpiutil/src/main/native/linux/MulticastServiceAnnouncer.cpp
deleted file mode 100644
index 1a7af39..0000000
--- a/wpiutil/src/main/native/linux/MulticastServiceAnnouncer.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceAnnouncer.h"
-
-#include <vector>
-
-#include "AvahiClient.h"
-#include "fmt/format.h"
-#include "wpi/mutex.h"
-
-using namespace wpi;
-
-struct MulticastServiceAnnouncer::Impl {
-  AvahiFunctionTable& table = AvahiFunctionTable::Get();
-  std::shared_ptr<AvahiThread> thread = AvahiThread::Get();
-  AvahiClient* client;
-  AvahiEntryGroup* group = nullptr;
-  std::string serviceName;
-  std::string serviceType;
-  int port;
-  AvahiStringList* stringList = nullptr;
-
-  ~Impl() noexcept {
-    if (stringList != nullptr && table.IsValid()) {
-      table.string_list_free(stringList);
-    }
-  }
-
-  template <typename T>
-  Impl(std::string_view serviceName, std::string_view serviceType, int port,
-       wpi::span<const std::pair<T, T>> txt);
-};
-
-template <typename T>
-MulticastServiceAnnouncer::Impl::Impl(std::string_view serviceName,
-                                      std::string_view serviceType, int port,
-                                      wpi::span<const std::pair<T, T>> txt) {
-  if (!this->table.IsValid()) {
-    return;
-  }
-
-  this->serviceName = serviceName;
-  this->serviceType = serviceType;
-  this->port = port;
-
-  std::vector<std::string> txts;
-  for (auto&& i : txt) {
-    txts.push_back(fmt::format("{}={}", i.first, i.second));
-  }
-
-  std::vector<const char*> txtArr;
-  for (auto&& i : txts) {
-    txtArr.push_back(i.c_str());
-  }
-
-  this->stringList =
-      this->table.string_list_new_from_array(txtArr.data(), txtArr.size());
-}
-
-static void RegisterService(AvahiClient* client,
-                            MulticastServiceAnnouncer::Impl* impl);
-
-static void EntryGroupCallback(AvahiEntryGroup* group,
-                               AvahiEntryGroupState state, void* userdata) {
-  if (state == AVAHI_ENTRY_GROUP_COLLISION) {
-    // Remote collision
-    MulticastServiceAnnouncer::Impl* impl =
-        reinterpret_cast<MulticastServiceAnnouncer::Impl*>(userdata);
-    char* newName =
-        impl->table.alternative_service_name(impl->serviceName.c_str());
-    impl->serviceName = newName;
-    impl->table.free(newName);
-    RegisterService(impl->table.entry_group_get_client(group), impl);
-  }
-}
-
-static void RegisterService(AvahiClient* client,
-                            MulticastServiceAnnouncer::Impl* impl) {
-  if (impl->group == nullptr) {
-    impl->group = impl->table.entry_group_new(client, EntryGroupCallback, impl);
-  }
-
-  while (true) {
-    if (impl->table.entry_group_is_empty(impl->group)) {
-      auto ret = impl->table.entry_group_add_service_strlst(
-          impl->group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
-          AVAHI_PUBLISH_USE_MULTICAST, impl->serviceName.c_str(),
-          impl->serviceType.c_str(), "local", nullptr, impl->port,
-          impl->stringList);
-      if (ret == AVAHI_ERR_COLLISION) {
-        // Local collision
-        char* newName =
-            impl->table.alternative_service_name(impl->serviceName.c_str());
-        impl->serviceName = newName;
-        impl->table.free(newName);
-        continue;
-      } else if (ret != AVAHI_OK) {
-        break;
-      }
-      impl->table.entry_group_commit(impl->group);
-      break;
-    }
-  }
-}
-
-static void ClientCallback(AvahiClient* client, AvahiClientState state,
-                           void* userdata) {
-  MulticastServiceAnnouncer::Impl* impl =
-      reinterpret_cast<MulticastServiceAnnouncer::Impl*>(userdata);
-
-  if (state == AVAHI_CLIENT_S_RUNNING) {
-    RegisterService(client, impl);
-  } else if (state == AVAHI_CLIENT_S_COLLISION ||
-             state == AVAHI_CLIENT_S_REGISTERING) {
-    if (impl->group) {
-      impl->table.entry_group_reset(impl->group);
-    }
-  }
-}
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string, std::string>> txt) {
-  pImpl = std::make_unique<Impl>(serviceName, serviceType, port, txt);
-}
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string_view, std::string_view>> txt) {
-  pImpl = std::make_unique<Impl>(serviceName, serviceType, port, txt);
-}
-
-MulticastServiceAnnouncer::~MulticastServiceAnnouncer() noexcept {
-  Stop();
-}
-
-bool MulticastServiceAnnouncer::HasImplementation() const {
-  return pImpl->table.IsValid();
-}
-
-void MulticastServiceAnnouncer::Start() {
-  if (!pImpl->table.IsValid()) {
-    return;
-  }
-  std::scoped_lock lock{*pImpl->thread};
-  if (pImpl->client) {
-    return;
-  }
-  pImpl->client =
-      pImpl->table.client_new(pImpl->thread->GetPoll(), AVAHI_CLIENT_NO_FAIL,
-                              ClientCallback, pImpl.get(), nullptr);
-}
-
-void MulticastServiceAnnouncer::Stop() {
-  if (!pImpl->table.IsValid()) {
-    return;
-  }
-  std::scoped_lock lock{*pImpl->thread};
-  if (pImpl->client) {
-    if (pImpl->group) {
-      pImpl->table.entry_group_free(pImpl->group);
-      pImpl->group = nullptr;
-    }
-    pImpl->table.client_free(pImpl->client);
-    pImpl->client = nullptr;
-  }
-}
diff --git a/wpiutil/src/main/native/linux/MulticastServiceResolver.cpp b/wpiutil/src/main/native/linux/MulticastServiceResolver.cpp
deleted file mode 100644
index 6585443..0000000
--- a/wpiutil/src/main/native/linux/MulticastServiceResolver.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceResolver.h"
-
-#include "AvahiClient.h"
-#include "wpi/SmallString.h"
-#include "wpi/StringExtras.h"
-#include "wpi/mutex.h"
-
-using namespace wpi;
-
-struct MulticastServiceResolver::Impl {
-  AvahiFunctionTable& table = AvahiFunctionTable::Get();
-  std::shared_ptr<AvahiThread> thread = AvahiThread::Get();
-  AvahiClient* client;
-  AvahiServiceBrowser* browser;
-  std::string serviceType;
-  MulticastServiceResolver* resolver;
-
-  void onFound(ServiceData&& data) {
-    resolver->PushData(std::forward<ServiceData>(data));
-  }
-};
-
-MulticastServiceResolver::MulticastServiceResolver(
-    std::string_view serviceType) {
-  pImpl = std::make_unique<Impl>();
-  pImpl->serviceType = serviceType;
-  pImpl->resolver = this;
-}
-
-MulticastServiceResolver::~MulticastServiceResolver() noexcept {
-  Stop();
-}
-
-bool MulticastServiceResolver::HasImplementation() const {
-  return pImpl->table.IsValid();
-}
-
-static void ResolveCallback(AvahiServiceResolver* r, AvahiIfIndex interface,
-                            AvahiProtocol protocol, AvahiResolverEvent event,
-                            const char* name, const char* type,
-                            const char* domain, const char* host_name,
-                            const AvahiAddress* address, uint16_t port,
-                            AvahiStringList* txt, AvahiLookupResultFlags flags,
-                            void* userdata) {
-  MulticastServiceResolver::Impl* impl =
-      reinterpret_cast<MulticastServiceResolver::Impl*>(userdata);
-
-  if (event == AVAHI_RESOLVER_FOUND) {
-    if (address->proto == AVAHI_PROTO_INET) {
-      AvahiStringList* strLst = txt;
-      MulticastServiceResolver::ServiceData data;
-      while (strLst != nullptr) {
-        std::string_view value{reinterpret_cast<const char*>(strLst->text),
-                               strLst->size};
-        strLst = strLst->next;
-        size_t splitIndex = value.find('=');
-        if (splitIndex == value.npos) {
-          // Todo make this just do key
-          continue;
-        }
-        std::string_view key = wpi::substr(value, 0, splitIndex);
-        value =
-            wpi::substr(value, splitIndex + 1, value.size() - splitIndex - 1);
-        data.txt.emplace_back(std::pair<std::string, std::string>{key, value});
-      }
-      wpi::SmallString<256> outputHostName;
-      char label[256];
-      do {
-        impl->table.unescape_label(&host_name, label, sizeof(label));
-        if (label[0] == '\0') {
-          break;
-        }
-        outputHostName.append(label);
-        outputHostName.append(".");
-      } while (true);
-
-      data.ipv4Address = address->data.ipv4.address;
-      data.port = port;
-      data.serviceName = name;
-      data.hostName = outputHostName.string();
-
-      impl->onFound(std::move(data));
-    }
-  }
-
-  impl->table.service_resolver_free(r);
-}
-
-static void BrowseCallback(AvahiServiceBrowser* b, AvahiIfIndex interface,
-                           AvahiProtocol protocol, AvahiBrowserEvent event,
-                           const char* name, const char* type,
-                           const char* domain, AvahiLookupResultFlags flags,
-                           void* userdata) {
-  MulticastServiceResolver::Impl* impl =
-      reinterpret_cast<MulticastServiceResolver::Impl*>(userdata);
-
-  if (event == AVAHI_BROWSER_NEW) {
-    impl->table.service_resolver_new(
-        impl->table.service_browser_get_client(b), interface, protocol, name,
-        type, domain, AVAHI_PROTO_UNSPEC, AVAHI_LOOKUP_USE_MULTICAST,
-        ResolveCallback, userdata);
-  }
-}
-
-static void ClientCallback(AvahiClient* client, AvahiClientState state,
-                           void* userdata) {
-  MulticastServiceResolver::Impl* impl =
-      reinterpret_cast<MulticastServiceResolver::Impl*>(userdata);
-
-  if (state == AVAHI_CLIENT_S_RUNNING) {
-    impl->browser = impl->table.service_browser_new(
-        client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, impl->serviceType.c_str(),
-        "local", AvahiLookupFlags::AVAHI_LOOKUP_USE_MULTICAST, BrowseCallback,
-        userdata);
-  }
-}
-
-void MulticastServiceResolver::Start() {
-  if (!pImpl->table.IsValid()) {
-    return;
-  }
-  std::scoped_lock lock{*pImpl->thread};
-  if (pImpl->client) {
-    return;
-  }
-
-  pImpl->client =
-      pImpl->table.client_new(pImpl->thread->GetPoll(), AVAHI_CLIENT_NO_FAIL,
-                              ClientCallback, pImpl.get(), nullptr);
-}
-
-void MulticastServiceResolver::Stop() {
-  if (!pImpl->table.IsValid()) {
-    return;
-  }
-  std::scoped_lock lock{*pImpl->thread};
-  if (pImpl->client) {
-    if (pImpl->browser) {
-      pImpl->table.service_browser_free(pImpl->browser);
-      pImpl->browser = nullptr;
-    }
-    pImpl->table.client_free(pImpl->client);
-    pImpl->client = nullptr;
-  }
-}
diff --git a/wpiutil/src/main/native/macOS/MulticastServiceAnnouncer.cpp b/wpiutil/src/main/native/macOS/MulticastServiceAnnouncer.cpp
deleted file mode 100644
index ad2ff48..0000000
--- a/wpiutil/src/main/native/macOS/MulticastServiceAnnouncer.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceAnnouncer.h"
-
-#include <wpi/SmallString.h>
-
-#include "dns_sd.h"
-
-using namespace wpi;
-
-struct MulticastServiceAnnouncer::Impl {
-  std::string serviceName;
-  std::string serviceType;
-  int port;
-  DNSServiceRef serviceRef{nullptr};
-  TXTRecordRef txtRecord;
-
-  Impl() { TXTRecordCreate(&txtRecord, 0, nullptr); }
-
-  ~Impl() noexcept { TXTRecordDeallocate(&txtRecord); }
-};
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string, std::string>> txt) {
-  pImpl = std::make_unique<Impl>();
-  pImpl->serviceName = serviceName;
-  pImpl->serviceType = serviceType;
-  pImpl->port = port;
-
-  for (auto&& i : txt) {
-    TXTRecordSetValue(&pImpl->txtRecord, i.first.c_str(), i.second.length(),
-                      i.second.c_str());
-  }
-}
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string_view, std::string_view>> txt) {
-  pImpl = std::make_unique<Impl>();
-  pImpl->serviceName = serviceName;
-  pImpl->serviceType = serviceType;
-  pImpl->port = port;
-
-  wpi::SmallString<64> key;
-
-  for (auto&& i : txt) {
-    key.clear();
-    key.append(i.first);
-    key.emplace_back('\0');
-
-    TXTRecordSetValue(&pImpl->txtRecord, key.data(), i.second.length(),
-                      i.second.data());
-  }
-}
-
-MulticastServiceAnnouncer::~MulticastServiceAnnouncer() noexcept {
-  Stop();
-}
-
-bool MulticastServiceAnnouncer::HasImplementation() const {
-  return true;
-}
-
-void MulticastServiceAnnouncer::Start() {
-  if (pImpl->serviceRef) {
-    return;
-  }
-
-  uint16_t len = TXTRecordGetLength(&pImpl->txtRecord);
-  const void* ptr = TXTRecordGetBytesPtr(&pImpl->txtRecord);
-
-  (void)DNSServiceRegister(&pImpl->serviceRef, 0, 0, pImpl->serviceName.c_str(),
-                           pImpl->serviceType.c_str(), "local", nullptr,
-                           htons(pImpl->port), len, ptr, nullptr, nullptr);
-}
-
-void MulticastServiceAnnouncer::Stop() {
-  if (!pImpl->serviceRef) {
-    return;
-  }
-  DNSServiceRefDeallocate(pImpl->serviceRef);
-  pImpl->serviceRef = nullptr;
-}
diff --git a/wpiutil/src/main/native/macOS/MulticastServiceResolver.cpp b/wpiutil/src/main/native/macOS/MulticastServiceResolver.cpp
deleted file mode 100644
index 4af8cad..0000000
--- a/wpiutil/src/main/native/macOS/MulticastServiceResolver.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/MulticastServiceResolver.h"
-
-#include <netinet/in.h>
-#include <poll.h>
-
-#include <atomic>
-#include <thread>
-#include <vector>
-
-#include "ResolverThread.h"
-#include "dns_sd.h"
-#include "wpi/SmallVector.h"
-
-using namespace wpi;
-
-struct DnsResolveState {
-  DnsResolveState(MulticastServiceResolver::Impl* impl,
-                  std::string_view serviceNameView)
-      : pImpl{impl} {
-    data.serviceName = serviceNameView;
-  }
-
-  DNSServiceRef ResolveRef = nullptr;
-  MulticastServiceResolver::Impl* pImpl;
-
-  MulticastServiceResolver::ServiceData data;
-};
-
-struct MulticastServiceResolver::Impl {
-  std::string serviceType;
-  MulticastServiceResolver* resolver;
-  std::shared_ptr<ResolverThread> thread = ResolverThread::Get();
-  std::vector<std::unique_ptr<DnsResolveState>> ResolveStates;
-  DNSServiceRef serviceRef = nullptr;
-
-  void onFound(ServiceData&& data) {
-    resolver->PushData(std::forward<ServiceData>(data));
-  }
-};
-
-MulticastServiceResolver::MulticastServiceResolver(
-    std::string_view serviceType) {
-  pImpl = std::make_unique<Impl>();
-  pImpl->serviceType = serviceType;
-  pImpl->resolver = this;
-}
-
-MulticastServiceResolver::~MulticastServiceResolver() noexcept {
-  Stop();
-}
-
-void ServiceGetAddrInfoReply(DNSServiceRef sdRef, DNSServiceFlags flags,
-                             uint32_t interfaceIndex,
-                             DNSServiceErrorType errorCode,
-                             const char* hostname,
-                             const struct sockaddr* address, uint32_t ttl,
-                             void* context) {
-  if (errorCode != kDNSServiceErr_NoError) {
-    return;
-  }
-
-  DnsResolveState* resolveState = static_cast<DnsResolveState*>(context);
-
-  resolveState->data.hostName = hostname;
-  resolveState->data.ipv4Address =
-      reinterpret_cast<const struct sockaddr_in*>(address)->sin_addr.s_addr;
-
-  resolveState->pImpl->onFound(std::move(resolveState->data));
-
-  resolveState->pImpl->thread->RemoveServiceRefInThread(
-      resolveState->ResolveRef);
-
-  resolveState->pImpl->ResolveStates.erase(std::find_if(
-      resolveState->pImpl->ResolveStates.begin(),
-      resolveState->pImpl->ResolveStates.end(),
-      [resolveState](auto& a) { return a.get() == resolveState; }));
-}
-
-void ServiceResolveReply(DNSServiceRef sdRef, DNSServiceFlags flags,
-                         uint32_t interfaceIndex, DNSServiceErrorType errorCode,
-                         const char* fullname, const char* hosttarget,
-                         uint16_t port, /* In network byte order */
-                         uint16_t txtLen, const unsigned char* txtRecord,
-                         void* context) {
-  if (errorCode != kDNSServiceErr_NoError) {
-    return;
-  }
-
-  DnsResolveState* resolveState = static_cast<DnsResolveState*>(context);
-  resolveState->pImpl->thread->RemoveServiceRefInThread(
-      resolveState->ResolveRef);
-  DNSServiceRefDeallocate(resolveState->ResolveRef);
-  resolveState->ResolveRef = nullptr;
-  resolveState->data.port = ntohs(port);
-
-  int txtCount = TXTRecordGetCount(txtLen, txtRecord);
-  char keyBuf[256];
-  uint8_t valueLen;
-  const void* value;
-
-  for (int i = 0; i < txtCount; i++) {
-    errorCode = TXTRecordGetItemAtIndex(txtLen, txtRecord, i, sizeof(keyBuf),
-                                        keyBuf, &valueLen, &value);
-    if (errorCode == kDNSServiceErr_NoError) {
-      if (valueLen == 0) {
-        // No value
-        resolveState->data.txt.emplace_back(
-            std::pair<std::string, std::string>{std::string{keyBuf}, {}});
-      } else {
-        resolveState->data.txt.emplace_back(std::pair<std::string, std::string>{
-            std::string{keyBuf},
-            std::string{reinterpret_cast<const char*>(value), valueLen}});
-      }
-    }
-  }
-
-  errorCode = DNSServiceGetAddrInfo(
-      &resolveState->ResolveRef, flags, interfaceIndex,
-      kDNSServiceProtocol_IPv4, hosttarget, ServiceGetAddrInfoReply, context);
-
-  if (errorCode == kDNSServiceErr_NoError) {
-    dnssd_sock_t socket = DNSServiceRefSockFD(resolveState->ResolveRef);
-    resolveState->pImpl->thread->AddServiceRef(resolveState->ResolveRef,
-                                               socket);
-  } else {
-    resolveState->pImpl->thread->RemoveServiceRefInThread(
-        resolveState->ResolveRef);
-    resolveState->pImpl->ResolveStates.erase(std::find_if(
-        resolveState->pImpl->ResolveStates.begin(),
-        resolveState->pImpl->ResolveStates.end(),
-        [resolveState](auto& a) { return a.get() == resolveState; }));
-  }
-}
-
-static void DnsCompletion(DNSServiceRef sdRef, DNSServiceFlags flags,
-                          uint32_t interfaceIndex,
-                          DNSServiceErrorType errorCode,
-                          const char* serviceName, const char* regtype,
-                          const char* replyDomain, void* context) {
-  if (errorCode != kDNSServiceErr_NoError) {
-    return;
-  }
-  if (!(flags & kDNSServiceFlagsAdd)) {
-    return;
-  }
-
-  MulticastServiceResolver::Impl* impl =
-      static_cast<MulticastServiceResolver::Impl*>(context);
-  auto& resolveState = impl->ResolveStates.emplace_back(
-      std::make_unique<DnsResolveState>(impl, serviceName));
-
-  errorCode = DNSServiceResolve(&resolveState->ResolveRef, 0, interfaceIndex,
-                                serviceName, regtype, replyDomain,
-                                ServiceResolveReply, resolveState.get());
-
-  if (errorCode == kDNSServiceErr_NoError) {
-    dnssd_sock_t socket = DNSServiceRefSockFD(resolveState->ResolveRef);
-    resolveState->pImpl->thread->AddServiceRef(resolveState->ResolveRef,
-                                               socket);
-  } else {
-    resolveState->pImpl->ResolveStates.erase(std::find_if(
-        resolveState->pImpl->ResolveStates.begin(),
-        resolveState->pImpl->ResolveStates.end(),
-        [r = resolveState.get()](auto& a) { return a.get() == r; }));
-  }
-}
-
-bool MulticastServiceResolver::HasImplementation() const {
-  return true;
-}
-
-void MulticastServiceResolver::Start() {
-  if (pImpl->serviceRef) {
-    return;
-  }
-
-  DNSServiceErrorType status =
-      DNSServiceBrowse(&pImpl->serviceRef, 0, 0, pImpl->serviceType.c_str(),
-                       "local", DnsCompletion, pImpl.get());
-  if (status == kDNSServiceErr_NoError) {
-    dnssd_sock_t socket = DNSServiceRefSockFD(pImpl->serviceRef);
-    pImpl->thread->AddServiceRef(pImpl->serviceRef, socket);
-  }
-}
-
-void MulticastServiceResolver::Stop() {
-  if (!pImpl->serviceRef) {
-    return;
-  }
-  wpi::SmallVector<WPI_EventHandle, 8> cleanupEvents;
-  for (auto&& i : pImpl->ResolveStates) {
-    cleanupEvents.push_back(
-        pImpl->thread->RemoveServiceRefOutsideThread(i->ResolveRef));
-  }
-  cleanupEvents.push_back(
-      pImpl->thread->RemoveServiceRefOutsideThread(pImpl->serviceRef));
-  wpi::SmallVector<WPI_Handle, 8> signaledBuf;
-  signaledBuf.resize(cleanupEvents.size());
-  while (!cleanupEvents.empty()) {
-    auto signaled = wpi::WaitForObjects(cleanupEvents, signaledBuf);
-    for (auto&& s : signaled) {
-      cleanupEvents.erase(
-          std::find(cleanupEvents.begin(), cleanupEvents.end(), s));
-    }
-  }
-
-  pImpl->ResolveStates.clear();
-  pImpl->serviceRef = nullptr;
-}
diff --git a/wpiutil/src/main/native/macOS/ResolverThread.cpp b/wpiutil/src/main/native/macOS/ResolverThread.cpp
deleted file mode 100644
index b91d6b6..0000000
--- a/wpiutil/src/main/native/macOS/ResolverThread.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "ResolverThread.h"
-
-#include "wpi/mutex.h"
-
-using namespace wpi;
-
-ResolverThread::ResolverThread(const private_init&) {}
-
-ResolverThread::~ResolverThread() noexcept {
-  running = false;
-  if (thread.joinable()) {
-    thread.join();
-  }
-}
-
-void ResolverThread::AddServiceRef(DNSServiceRef serviceRef,
-                                   dnssd_sock_t socket) {
-  std::scoped_lock lock{serviceRefMutex};
-  serviceRefs.emplace_back(
-      std::pair<DNSServiceRef, dnssd_sock_t>{serviceRef, socket});
-  if (serviceRefs.size() == 1) {
-    running = false;
-    if (thread.joinable()) {
-      thread.join();
-    }
-    running = true;
-    thread = std::thread([=] { ThreadMain(); });
-  }
-}
-
-void ResolverThread::RemoveServiceRefInThread(DNSServiceRef serviceRef) {
-  std::scoped_lock lock{serviceRefMutex};
-  serviceRefs.erase(
-      std::find_if(serviceRefs.begin(), serviceRefs.end(),
-                   [=](auto& a) { return a.first == serviceRef; }));
-  DNSServiceRefDeallocate(serviceRef);
-}
-
-WPI_EventHandle ResolverThread::RemoveServiceRefOutsideThread(
-    DNSServiceRef serviceRef) {
-  std::scoped_lock lock{serviceRefMutex};
-  WPI_EventHandle handle = CreateEvent(true);
-  serviceRefsToRemove.push_back({serviceRef, handle});
-  return handle;
-}
-
-bool ResolverThread::CleanupRefs() {
-  std::scoped_lock lock{serviceRefMutex};
-  for (auto&& r : serviceRefsToRemove) {
-    serviceRefs.erase(
-        std::find_if(serviceRefs.begin(), serviceRefs.end(),
-                     [=](auto& a) { return a.first == r.first; }));
-    DNSServiceRefDeallocate(r.first);
-    wpi::SetEvent(r.second);
-  }
-  serviceRefsToRemove.clear();
-  return serviceRefs.empty();
-}
-
-void ResolverThread::ThreadMain() {
-  std::vector<pollfd> readSockets;
-  std::vector<DNSServiceRef> serviceRefs;
-
-  while (running) {
-    readSockets.clear();
-    serviceRefs.clear();
-
-    for (auto&& i : this->serviceRefs) {
-      readSockets.emplace_back(pollfd{i.second, POLLIN, 0});
-      serviceRefs.emplace_back(i.first);
-    }
-
-    int res = poll(readSockets.begin().base(), readSockets.size(), 100);
-
-    if (res > 0) {
-      for (size_t i = 0; i < readSockets.size(); i++) {
-        if (readSockets[i].revents == POLLIN) {
-          DNSServiceProcessResult(serviceRefs[i]);
-        }
-      }
-    } else if (res == 0) {
-      if (!running) {
-        CleanupRefs();
-        break;
-      }
-    }
-
-    if (CleanupRefs()) {
-      break;
-    }
-  }
-}
-
-static wpi::mutex ThreadLoopLock;
-static std::weak_ptr<ResolverThread> ThreadLoop;
-
-std::shared_ptr<ResolverThread> ResolverThread::Get() {
-  std::scoped_lock lock{ThreadLoopLock};
-  auto locked = ThreadLoop.lock();
-  if (!locked) {
-    locked = std::make_unique<ResolverThread>(private_init{});
-    ThreadLoop = locked;
-  }
-  return locked;
-}
diff --git a/wpiutil/src/main/native/macOS/ResolverThread.h b/wpiutil/src/main/native/macOS/ResolverThread.h
deleted file mode 100644
index 0162de5..0000000
--- a/wpiutil/src/main/native/macOS/ResolverThread.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <netinet/in.h>
-#include <poll.h>
-
-#include <atomic>
-#include <memory>
-#include <thread>
-#include <utility>
-#include <vector>
-
-#include "dns_sd.h"
-#include "wpi/Synchronization.h"
-#include "wpi/mutex.h"
-
-namespace wpi {
-class ResolverThread {
- private:
-  struct private_init {};
-
- public:
-  explicit ResolverThread(const private_init&);
-  ~ResolverThread() noexcept;
-
-  void AddServiceRef(DNSServiceRef serviceRef, dnssd_sock_t socket);
-  void RemoveServiceRefInThread(DNSServiceRef serviceRef);
-  WPI_EventHandle RemoveServiceRefOutsideThread(DNSServiceRef serviceRef);
-
-  static std::shared_ptr<ResolverThread> Get();
-
- private:
-  void ThreadMain();
-  bool CleanupRefs();
-
-  wpi::mutex serviceRefMutex;
-  std::vector<std::pair<DNSServiceRef, WPI_EventHandle>> serviceRefsToRemove;
-  std::vector<std::pair<DNSServiceRef, dnssd_sock_t>> serviceRefs;
-  std::thread thread;
-  std::atomic_bool running;
-};
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/resources/bootstrap-4.1.min.js.gz b/wpiutil/src/main/native/resources/bootstrap-4.1.min.js.gz
deleted file mode 100644
index a7797e1..0000000
--- a/wpiutil/src/main/native/resources/bootstrap-4.1.min.js.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/resources/coreui-2.1.min.css.gz b/wpiutil/src/main/native/resources/coreui-2.1.min.css.gz
deleted file mode 100644
index d4f43ad..0000000
--- a/wpiutil/src/main/native/resources/coreui-2.1.min.css.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/resources/coreui-2.1.min.js.gz b/wpiutil/src/main/native/resources/coreui-2.1.min.js.gz
deleted file mode 100644
index cf4ccb1..0000000
--- a/wpiutil/src/main/native/resources/coreui-2.1.min.js.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/resources/feather-4.8.min.js.gz b/wpiutil/src/main/native/resources/feather-4.8.min.js.gz
deleted file mode 100644
index d275865..0000000
--- a/wpiutil/src/main/native/resources/feather-4.8.min.js.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/resources/jquery-3.3.slim.min.js.gz b/wpiutil/src/main/native/resources/jquery-3.3.slim.min.js.gz
deleted file mode 100644
index 712e06c..0000000
--- a/wpiutil/src/main/native/resources/jquery-3.3.slim.min.js.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/resources/popper-1.14.min.js.gz b/wpiutil/src/main/native/resources/popper-1.14.min.js.gz
deleted file mode 100644
index c6ebec8..0000000
--- a/wpiutil/src/main/native/resources/popper-1.14.min.js.gz
+++ /dev/null
Binary files differ
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/args.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/args.h
similarity index 95%
rename from wpiutil/src/main/native/fmtlib/include/fmt/args.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/args.h
index 9a8e4ed..a3966d1 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/args.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/args.h
@@ -95,10 +95,10 @@
   };
 
   template <typename T>
-  using stored_type = conditional_t<detail::is_string<T>::value &&
-                                        !has_formatter<T, Context>::value &&
-                                        !detail::is_reference_wrapper<T>::value,
-                                    std::basic_string<char_type>, 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_;
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/chrono.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/chrono.h
similarity index 95%
rename from wpiutil/src/main/native/fmtlib/include/fmt/chrono.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/chrono.h
index 682efd8..b112f76 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/chrono.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/chrono.h
@@ -10,6 +10,8 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cmath>    // std::isfinite
+#include <cstring>  // std::memcpy
 #include <ctime>
 #include <iterator>
 #include <locale>
@@ -201,7 +203,7 @@
     }
     const auto min1 =
         (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
-    if (count < min1) {
+    if (!std::is_unsigned<IntermediateRep>::value && count < min1) {
       ec = 1;
       return {};
     }
@@ -321,14 +323,13 @@
 template <typename CodeUnit>
 void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
                    const std::locale& loc) {
-  using codecvt = std::codecvt<CodeUnit, char, std::mbstate_t>;
 #if FMT_CLANG_VERSION
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wdeprecated"
-  auto& f = std::use_facet<codecvt>(loc);
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
 #  pragma clang diagnostic pop
 #else
-  auto& f = std::use_facet<codecvt>(loc);
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
 #endif
   auto mb = std::mbstate_t();
   const char* from_next = nullptr;
@@ -344,7 +345,7 @@
   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_VER != 0 || \
+#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.
@@ -468,7 +469,7 @@
 
     bool fallback(int res) { return res == 0; }
 
-#if !FMT_MSC_VER
+#if !FMT_MSC_VERSION
     bool fallback(detail::null<>) {
       using namespace fmt::detail;
       std::tm* tm = std::localtime(&time_);
@@ -514,7 +515,7 @@
 
     bool fallback(int res) { return res == 0; }
 
-#if !FMT_MSC_VER
+#if !FMT_MSC_VERSION
     bool fallback(detail::null<>) {
       std::tm* tm = std::gmtime(&time_);
       if (tm) tm_ = *tm;
@@ -562,10 +563,10 @@
   constexpr const size_t len = 8;
   if (const_check(is_big_endian())) {
     char tmp[len];
-    memcpy(tmp, &digits, len);
+    std::memcpy(tmp, &digits, len);
     std::reverse_copy(tmp, tmp + len, buf);
   } else {
-    memcpy(buf, &digits, len);
+    std::memcpy(buf, &digits, len);
   }
 }
 
@@ -1214,7 +1215,7 @@
     char buf[10];
     size_t offset = 0;
     if (year >= 0 && year < 10000) {
-      copy2(buf, digits2(to_unsigned(year / 100)));
+      copy2(buf, digits2(static_cast<size_t>(year / 100)));
     } else {
       offset = 4;
       write_year_extended(year);
@@ -1388,15 +1389,6 @@
 };
 
 template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-inline bool isnan(T) {
-  return false;
-}
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-inline bool isnan(T value) {
-  return std::isnan(value);
-}
-
-template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
 inline bool isfinite(T) {
   return true;
 }
@@ -1404,7 +1396,8 @@
 // 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 Int to_nonnegative_int(T value, Int upper) {
-  FMT_ASSERT(value >= 0 && to_unsigned(value) <= to_unsigned(upper),
+  FMT_ASSERT(std::is_unsigned<Int>::value ||
+             (value >= 0 && to_unsigned(value) <= to_unsigned(upper)),
              "invalid value");
   (void)upper;
   return static_cast<Int>(value);
@@ -1470,14 +1463,22 @@
 #endif
 }
 
-// Returns the number of fractional digits in the range [0, 18] according to the
+// 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.
-constexpr int count_fractional_digits(long long num, long long den, int n = 0) {
-  return num % den == 0
-             ? n
-             : (n > 18 ? 6 : count_fractional_digits(num * 10, den, n + 1));
-}
+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;
+};
 
 constexpr long long pow10(std::uint32_t n) {
   return n == 0 ? 1 : 10 * pow10(n - 1);
@@ -1663,9 +1664,11 @@
     out = format_decimal<char_type>(out, n, num_digits).end;
   }
 
-  template <class Duration> void write_fractional_seconds(Duration d) {
+  template <typename Duration> void write_fractional_seconds(Duration d) {
+    FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
     constexpr auto num_fractional_digits =
-        count_fractional_digits(Duration::period::num, Duration::period::den);
+        count_fractional_digits<Duration::period::num,
+                                Duration::period::den>::value;
 
     using subsecond_precision = std::chrono::duration<
         typename std::common_type<typename Duration::rep,
@@ -1674,12 +1677,9 @@
     if (std::ratio_less<typename subsecond_precision::period,
                         std::chrono::seconds::period>::value) {
       *out++ = '.';
-      // Don't convert long double to integer seconds to avoid overflow.
-      using sec = conditional_t<
-          std::is_same<typename Duration::rep, long double>::value,
-          std::chrono::duration<long double>, std::chrono::seconds>;
-      auto fractional = detail::abs(d) - std::chrono::duration_cast<sec>(d);
-      const auto subseconds =
+      auto fractional =
+          detail::abs(d) - std::chrono::duration_cast<std::chrono::seconds>(d);
+      auto subseconds =
           std::chrono::treat_as_floating_point<
               typename subsecond_precision::rep>::value
               ? fractional.count()
@@ -1770,8 +1770,22 @@
     if (handle_nan_inf()) return;
 
     if (ns == numeric_system::standard) {
-      write(second(), 2);
-      write_fractional_seconds(std::chrono::duration<rep, Period>{val});
+      if (std::is_floating_point<rep>::value) {
+        constexpr auto num_fractional_digits =
+            count_fractional_digits<Period::num, Period::den>::value;
+        auto buf = memory_buffer();
+        format_to(std::back_inserter(buf), runtime("{:.{}f}"),
+                  std::fmod(val * static_cast<rep>(Period::num) /
+                                static_cast<rep>(Period::den),
+                            static_cast<rep>(60)),
+                  num_fractional_digits);
+        if (negative) *out++ = '-';
+        if (buf.size() < 2 || buf[1] == '.') *out++ = '0';
+        out = std::copy(buf.begin(), buf.end(), out);
+      } else {
+        write(second(), 2);
+        write_fractional_seconds(std::chrono::duration<rep, Period>(val));
+      }
       return;
     }
     auto time = tm();
@@ -1988,13 +2002,9 @@
 struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
                  Char> : formatter<std::tm, Char> {
   FMT_CONSTEXPR formatter() {
-    this->do_parse(default_specs,
-                   default_specs + sizeof(default_specs) / sizeof(Char));
-  }
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return this->do_parse(ctx.begin(), ctx.end(), true);
+    basic_string_view<Char> default_specs =
+        detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+    this->do_parse(default_specs.begin(), default_specs.end());
   }
 
   template <typename FormatContext>
@@ -2002,15 +2012,8 @@
               FormatContext& ctx) const -> decltype(ctx.out()) {
     return formatter<std::tm, Char>::format(localtime(val), ctx);
   }
-
-  static constexpr const Char default_specs[] = {'%', 'F', ' ', '%', 'T'};
 };
 
-template <typename Char, typename Duration>
-constexpr const Char
-    formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
-              Char>::default_specs[];
-
 template <typename Char> struct formatter<std::tm, Char> {
  private:
   enum class spec {
@@ -2022,13 +2025,18 @@
   basic_string_view<Char> specs;
 
  protected:
-  template <typename It>
-  FMT_CONSTEXPR auto do_parse(It begin, It end, bool with_default = false)
-      -> It {
+  template <typename It> FMT_CONSTEXPR auto do_parse(It begin, It end) -> It {
     if (begin != end && *begin == ':') ++begin;
     end = detail::parse_chrono_format(begin, end, detail::tm_format_checker());
-    if (!with_default || end != begin)
-      specs = {begin, detail::to_unsigned(end - begin)};
+    // Replace default spec only if the new spec is not empty.
+    if (end != begin) specs = {begin, detail::to_unsigned(end - begin)};
+    return end;
+  }
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto end = this->do_parse(ctx.begin(), ctx.end());
     // basic_string_view<>::compare isn't constexpr before C++17.
     if (specs.size() == 2 && specs[0] == Char('%')) {
       if (specs[1] == Char('F'))
@@ -2039,12 +2047,6 @@
     return end;
   }
 
- public:
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return this->do_parse(ctx.begin(), ctx.end());
-  }
-
   template <typename FormatContext>
   auto format(const std::tm& tm, FormatContext& ctx) const
       -> decltype(ctx.out()) {
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/color.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/color.h
similarity index 80%
rename from wpiutil/src/main/native/fmtlib/include/fmt/color.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/color.h
index dfbe482..4c16327 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/color.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/color.h
@@ -10,13 +10,6 @@
 
 #include "format.h"
 
-// __declspec(deprecated) is broken in some MSVC versions.
-#if FMT_MSC_VER
-#  define FMT_DEPRECATED_NONMSVC
-#else
-#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
-#endif
-
 FMT_BEGIN_NAMESPACE
 FMT_MODULE_EXPORT_BEGIN
 
@@ -214,17 +207,16 @@
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
-  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
-  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
-                                                           value{} {
+  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) FMT_NOEXCEPT : is_rgb(true), value{} {
+  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) FMT_NOEXCEPT : is_rgb(),
-                                                                     value{} {
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+      : is_rgb(), value{} {
     value.term_color = static_cast<uint8_t>(term_color);
   }
   bool is_rgb;
@@ -239,10 +231,8 @@
 /** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
  public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems(em) {}
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : set_foreground_color(), set_background_color(), ems(em) {}
 
   FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
     if (!set_foreground_color) {
@@ -273,44 +263,32 @@
     return lhs |= rhs;
   }
 
-  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
-      const text_style& rhs) {
-    return and_assign(rhs);
-  }
-
-  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
-  operator&(text_style lhs, const text_style& rhs) {
-    return lhs.and_assign(rhs);
-  }
-
-  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_foreground() const noexcept {
     return set_foreground_color;
   }
-  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_background() const noexcept {
     return set_background_color;
   }
-  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR bool has_emphasis() const noexcept {
     return static_cast<uint8_t>(ems) != 0;
   }
-  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
     FMT_ASSERT(has_foreground(), "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
     FMT_ASSERT(has_background(), "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
     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) FMT_NOEXCEPT
-      : set_foreground_color(),
-        set_background_color(),
-        ems() {
+                           detail::color_type text_color) noexcept
+      : set_foreground_color(), set_background_color(), ems() {
     if (is_foreground) {
       foreground_color = text_color;
       set_foreground_color = true;
@@ -320,36 +298,9 @@
     }
   }
 
-  // DEPRECATED!
-  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
-    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 AND a terminal color"));
-      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
-    }
+  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
 
-    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 AND 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_DECL text_style fg(detail::color_type foreground)
-      FMT_NOEXCEPT;
-
-  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
-      FMT_NOEXCEPT;
+  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
 
   detail::color_type foreground_color;
   detail::color_type background_color;
@@ -359,17 +310,16 @@
 };
 
 /** Creates a text style from the foreground (text) color. */
-FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
   return text_style(true, foreground);
 }
 
 /** Creates a text style from the background color. */
-FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
   return text_style(false, background);
 }
 
-FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
-                                          emphasis rhs) FMT_NOEXCEPT {
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
   return text_style(lhs) | rhs;
 }
 
@@ -377,7 +327,7 @@
 
 template <typename Char> struct ansi_color_escape {
   FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
-                                  const char* esc) FMT_NOEXCEPT {
+                                  const char* esc) noexcept {
     // If we have a terminal color, we need to output another escape code
     // sequence.
     if (!text_color.is_rgb) {
@@ -412,7 +362,7 @@
     to_esc(color.b, buffer + 15, 'm');
     buffer[19] = static_cast<Char>(0);
   }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+  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;
@@ -433,10 +383,10 @@
     }
     buffer[index++] = static_cast<Char>(0);
   }
-  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
 
-  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
-  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
+  FMT_CONSTEXPR const Char* begin() const noexcept { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
     return buffer + std::char_traits<Char>::length(buffer);
   }
 
@@ -445,59 +395,64 @@
   Char buffer[7u + 3u * num_emphases + 1u];
 
   static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) FMT_NOEXCEPT {
+                                   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 bool has_emphasis(emphasis em,
-                                         emphasis mask) FMT_NOEXCEPT {
+  static FMT_CONSTEXPR bool has_emphasis(emphasis em, emphasis mask) noexcept {
     return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
   }
 };
 
 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    detail::color_type foreground) FMT_NOEXCEPT {
+    detail::color_type foreground) noexcept {
   return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
 }
 
 template <typename Char>
 FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
-    detail::color_type background) FMT_NOEXCEPT {
+    detail::color_type background) noexcept {
   return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
   return ansi_color_escape<Char>(em);
 }
 
-template <typename Char>
-inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputs(chars, stream);
+template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
+  int result = std::fputs(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
-template <>
-inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
-  std::fputws(chars, stream);
+template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
+  int result = std::fputws(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
-template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+template <typename Char> inline void reset_color(FILE* stream) {
   fputs("\x1b[0m", stream);
 }
 
-template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+template <> inline void reset_color<wchar_t>(FILE* stream) {
   fputs(L"\x1b[0m", stream);
 }
 
-template <typename Char>
-inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
+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 {
+  const T& value;
+  text_style style;
+};
+
 template <typename Char>
 void vformat_to(buffer<Char>& buf, const text_style& ts,
                 basic_string_view<Char> format_str,
@@ -528,9 +483,13 @@
 void vprint(std::FILE* f, const text_style& ts, const S& format,
             basic_format_args<buffer_context<type_identity_t<Char>>> args) {
   basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format), args);
-  buf.push_back(Char(0));
-  detail::fputs(buf.data(), f);
+  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+  if (detail::is_utf8()) {
+    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+  } else {
+    buf.push_back(Char(0));
+    detail::fputs(buf.data(), f);
+  }
 }
 
 /**
@@ -549,7 +508,7 @@
 void print(std::FILE* f, const text_style& ts, const S& format_str,
            const Args&... args) {
   vprint(f, ts, format_str,
-         fmt::make_args_checked<Args...>(format_str, args...));
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }
 
 /**
@@ -574,7 +533,7 @@
     const text_style& ts, const S& format_str,
     basic_format_args<buffer_context<type_identity_t<Char>>> args) {
   basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, to_string_view(format_str), args);
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
   return fmt::to_string(buf);
 }
 
@@ -593,8 +552,8 @@
 template <typename S, typename... Args, typename Char = char_t<S>>
 inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
                                       const Args&... args) {
-  return fmt::vformat(ts, to_string_view(format_str),
-                      fmt::make_args_checked<Args...>(format_str, args...));
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 /**
@@ -628,8 +587,62 @@
 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, to_string_view(format_str),
-                    fmt::make_args_checked<Args...>(format_str, args...));
+  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_MODULE_EXPORT_END
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/compile.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/compile.h
similarity index 88%
rename from wpiutil/src/main/native/fmtlib/include/fmt/compile.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/compile.h
index 1dba3dd..933668c 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/compile.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/compile.h
@@ -13,48 +13,9 @@
 FMT_BEGIN_NAMESPACE
 namespace detail {
 
-// 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;
-  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
-
-  struct value_type {
-    template <typename T> void operator=(const T&) {}
-  };
-
-  counting_iterator() : count_(0) {}
-
-  size_t count() const { return count_; }
-
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
-
-  friend counting_iterator operator+(counting_iterator it, difference_type n) {
-    it.count_ += static_cast<size_t>(n);
-    return it;
-  }
-
-  value_type operator*() const { return {}; }
-};
-
 template <typename Char, typename InputIt>
-inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                  counting_iterator it) {
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                                counting_iterator it) {
   return it + (end - begin);
 }
 
@@ -75,8 +36,7 @@
   using difference_type = std::ptrdiff_t;
   using pointer = void;
   using reference = void;
-  using _Unchecked_type =
-      truncating_iterator_base;  // Mark iterator as checked.
+  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
 
   OutputIt base() const { return out_; }
   size_t count() const { return count_; }
@@ -163,12 +123,12 @@
 #  define FMT_COMPILE(s) FMT_STRING(s)
 #endif
 
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#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;
-  constexpr operator basic_string_view<char_type>() const {
+  explicit constexpr operator basic_string_view<char_type>() const {
     return {Str.data, N - 1};
   }
 };
@@ -377,10 +337,11 @@
 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 = basic_format_parse_context<Char>(str, {}, next_arg_id);
+  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()) + 1,
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
           next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
 }
 
@@ -436,13 +397,20 @@
     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 == ':') {
+  } 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);
-    return parse_tail<Args, result.end, result.next_arg_id>(
-        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
-            result.fmt},
-        format_str);
+    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);
+    }
   }
 }
 
@@ -573,10 +541,11 @@
   constexpr auto compiled = detail::compile<Args...>(S());
   if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                              detail::unknown_format>()) {
-    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
-                  std::forward<Args>(args)...);
+    return fmt::format(
+        static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
   } else {
-    return format(compiled, std::forward<Args>(args)...);
+    return fmt::format(compiled, std::forward<Args>(args)...);
   }
 }
 
@@ -586,11 +555,11 @@
   constexpr auto compiled = detail::compile<Args...>(S());
   if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
                              detail::unknown_format>()) {
-    return format_to(out,
-                     static_cast<basic_string_view<typename S::char_type>>(S()),
-                     std::forward<Args>(args)...);
+    return fmt::format_to(
+        out, static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
   } else {
-    return format_to(out, compiled, std::forward<Args>(args)...);
+    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
   }
 }
 #endif
@@ -599,22 +568,24 @@
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
 format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
                                          const S& format_str, Args&&... args) {
-  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
-                      std::forward<Args>(args)...);
+  auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
+                           format_str, std::forward<Args>(args)...);
   return {it.base(), it.count()};
 }
 
 template <typename S, typename... Args,
           FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
-size_t formatted_size(const S& format_str, const Args&... args) {
-  return format_to(detail::counting_iterator(), format_str, args...).count();
+FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
+                                      const Args&... args) {
+  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;
-  format_to(std::back_inserter(buffer), format_str, args...);
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
   detail::print(f, {buffer.data(), buffer.size()});
 }
 
@@ -624,14 +595,12 @@
   print(stdout, format_str, args...);
 }
 
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
 inline namespace literals {
-template <detail_exported::fixed_string Str>
-constexpr detail::udl_compiled_string<
-    remove_cvref_t<decltype(Str.data[0])>,
-    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
-operator""_cf() {
-  return {};
+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
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/core.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/core.h
similarity index 85%
rename from wpiutil/src/main/native/fmtlib/include/fmt/core.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/core.h
index 92a7aa1..5c210bc 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/core.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/core.h
@@ -10,14 +10,14 @@
 
 #include <cstddef>  // std::byte
 #include <cstdio>   // std::FILE
-#include <cstring>
+#include <cstring>  // std::strlen
 #include <iterator>
 #include <limits>
 #include <string>
 #include <type_traits>
 
 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 80101
+#define FMT_VERSION 90100
 
 #if defined(__clang__) && !defined(__ibmxl__)
 #  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
@@ -49,29 +49,29 @@
 #  define FMT_ICC_VERSION 0
 #endif
 
-#ifdef __NVCC__
-#  define FMT_NVCC __NVCC__
-#else
-#  define FMT_NVCC 0
-#endif
-
 #ifdef _MSC_VER
-#  define FMT_MSC_VER _MSC_VER
+#  define FMT_MSC_VERSION _MSC_VER
 #  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
 #else
-#  define FMT_MSC_VER 0
+#  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) &&                             \
-    (!defined(__INTELLISENSE__) || FMT_MSC_VER > 1900) && \
-    (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1600)
+#if (defined(__has_include) || FMT_ICC_VERSION >= 1600 || \
+     FMT_MSC_VERSION > 1900) &&                           \
+    !defined(__INTELLISENSE__)
 #  define FMT_HAS_INCLUDE(x) __has_include(x)
 #else
 #  define FMT_HAS_INCLUDE(x) 0
@@ -83,12 +83,6 @@
 #  define FMT_HAS_CPP_ATTRIBUTE(x) 0
 #endif
 
-#ifdef _MSVC_LANG
-#  define FMT_CPLUSPLUS _MSVC_LANG
-#else
-#  define FMT_CPLUSPLUS __cplusplus
-#endif
-
 #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
   (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
 
@@ -98,37 +92,38 @@
 // Check if relaxed C++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
 #ifndef FMT_USE_CONSTEXPR
-#  define FMT_USE_CONSTEXPR                                           \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1912 || \
-     (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) &&           \
-        !FMT_NVCC && !FMT_ICC_VERSION
+#  if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \
+       (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) &&             \
+      !FMT_ICC_VERSION && !defined(__NVCC__)
+#    define FMT_USE_CONSTEXPR 1
+#  else
+#    define FMT_USE_CONSTEXPR 0
+#  endif
 #endif
 #if FMT_USE_CONSTEXPR
 #  define FMT_CONSTEXPR constexpr
-#  define FMT_CONSTEXPR_DECL constexpr
 #else
 #  define FMT_CONSTEXPR
-#  define FMT_CONSTEXPR_DECL
 #endif
 
-#if ((__cplusplus >= 202002L) &&                              \
+#if ((FMT_CPLUSPLUS >= 202002L) &&                            \
      (!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE > 9)) || \
-    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
+    (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)
 #  define FMT_CONSTEXPR20 constexpr
 #else
 #  define FMT_CONSTEXPR20
 #endif
 
-// Check if constexpr std::char_traits<>::compare,length is supported.
+// Check if constexpr std::char_traits<>::{compare,length} are supported.
 #if defined(__GLIBCXX__)
-#  if __cplusplus >= 201703L && defined(_GLIBCXX_RELEASE) && \
+#  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) && __cplusplus >= 201703L && \
+#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \
     _LIBCPP_VERSION >= 4000
 #  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
-#elif FMT_MSC_VER >= 1914 && _MSVC_LANG >= 201703L
+#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L
 #  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
 #endif
 #ifndef FMT_CONSTEXPR_CHAR_TRAITS
@@ -138,57 +133,43 @@
 // Check if exceptions are disabled.
 #ifndef FMT_EXCEPTIONS
 #  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
-      FMT_MSC_VER && !_HAS_EXCEPTIONS
+      (FMT_MSC_VERSION && !_HAS_EXCEPTIONS)
 #    define FMT_EXCEPTIONS 0
 #  else
 #    define FMT_EXCEPTIONS 1
 #  endif
 #endif
 
-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-#  define FMT_USE_NOEXCEPT 0
-#endif
-
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    FMT_GCC_VERSION >= 408 || FMT_MSC_VER >= 1900
-#  define FMT_DETECTED_NOEXCEPT noexcept
-#  define FMT_HAS_CXX11_NOEXCEPT 1
-#else
-#  define FMT_DETECTED_NOEXCEPT throw()
-#  define FMT_HAS_CXX11_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-#  if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
-#    define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
+#ifndef FMT_DEPRECATED
+#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900
+#    define FMT_DEPRECATED [[deprecated]]
 #  else
-#    define FMT_NOEXCEPT
+#    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
 
 // [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
 // warnings.
-#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
-    !FMT_NVCC
+#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \
+    !defined(__NVCC__)
 #  define FMT_NORETURN [[noreturn]]
 #else
 #  define FMT_NORETURN
 #endif
 
-#if __cplusplus == 201103L || __cplusplus == 201402L
-#  if defined(__INTEL_COMPILER) || defined(__PGI)
-#    define FMT_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
-#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
+#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
@@ -219,24 +200,20 @@
 #  endif
 #endif
 
-#ifndef FMT_DEPRECATED
-#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
-#    define FMT_DEPRECATED [[deprecated]]
-#  else
-#    if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
-#      define FMT_DEPRECATED __attribute__((deprecated))
-#    elif FMT_MSC_VER
-#      define FMT_DEPRECATED __declspec(deprecated)
-#    else
-#      define FMT_DEPRECATED /* deprecated */
-#    endif
-#  endif
+// An inline std::forward replacement.
+#define FMT_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+#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 v8 {
+    inline namespace v9 {
 #  define FMT_END_NAMESPACE \
     }                       \
     }
@@ -270,25 +247,24 @@
 #endif
 
 // libc++ supports string_view in pre-c++17.
-#if (FMT_HAS_INCLUDE(<string_view>) &&                       \
-     (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
-    (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
+#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") && __cplusplus >= 201402L
+#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_VER
+#  define FMT_UNICODE !FMT_MSC_VERSION
 #endif
 
 #ifndef FMT_CONSTEVAL
-#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) &&      \
-       __cplusplus > 201703L && !defined(__apple_build_version__)) || \
-      (defined(__cpp_consteval) &&                                    \
-       (!FMT_MSC_VER || _MSC_FULL_VER >= 193030704))
+#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) &&         \
+       FMT_CPLUSPLUS >= 202002L && !defined(__apple_build_version__)) || \
+      (defined(__cpp_consteval) &&                                       \
+       (!FMT_MSC_VERSION || _MSC_FULL_VER >= 193030704))
 // consteval is broken in MSVC before VS2022 and Apple clang 13.
 #    define FMT_CONSTEVAL consteval
 #    define FMT_HAS_CONSTEVAL
@@ -297,19 +273,20 @@
 #  endif
 #endif
 
-#ifndef FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
-#  if defined(__cpp_nontype_template_args) &&                \
-      ((FMT_GCC_VERSION >= 903 && __cplusplus >= 201709L) || \
-       __cpp_nontype_template_args >= 201911L)
-#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 1
+#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)
+#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
 #  else
-#    define FMT_USE_NONTYPE_TEMPLATE_PARAMETERS 0
+#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
 #  endif
 #endif
 
 // Enable minimal optimizations for more compact code in debug mode.
 FMT_GCC_PRAGMA("GCC push_options")
-#ifndef __OPTIMIZE__
+#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER)
 FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
 #endif
 
@@ -330,6 +307,20 @@
 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;
+
+template <typename...> struct disjunction : std::false_type {};
+template <typename P> struct disjunction<P> : P {};
+template <typename P1, typename... Pn>
+struct disjunction<P1, Pn...>
+    : conditional_t<bool(P1::value), P1, disjunction<Pn...>> {};
+
+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> {};
 
 struct monostate {
   constexpr monostate() {}
@@ -346,13 +337,13 @@
 
 FMT_BEGIN_DETAIL_NAMESPACE
 
-// Suppress "unused variable" warnings with the method described in
+// 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)
-    FMT_NOEXCEPT -> bool {
+constexpr FMT_INLINE auto is_constant_evaluated(
+    bool default_value = false) noexcept -> bool {
 #ifdef __cpp_lib_is_constant_evaluated
   ignore_unused(default_value);
   return std::is_constant_evaluated();
@@ -361,7 +352,7 @@
 #endif
 }
 
-// A function to suppress "conditional expression is constant" warnings.
+// Suppresses "conditional expression is constant" warnings.
 template <typename T> constexpr FMT_INLINE auto const_check(T value) -> T {
   return value;
 }
@@ -371,7 +362,7 @@
 
 #ifndef FMT_ASSERT
 #  ifdef NDEBUG
-// FMT_ASSERT is not empty to avoid -Werror=empty-body.
+// FMT_ASSERT is not empty to avoid -Wempty-body.
 #    define FMT_ASSERT(condition, message) \
       ::fmt::detail::ignore_unused((condition), (message))
 #  else
@@ -382,12 +373,6 @@
 #  endif
 #endif
 
-#ifdef __cpp_lib_byte
-using byte = std::byte;
-#else
-enum class byte : unsigned char {};
-#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)
@@ -399,11 +384,11 @@
 
 #ifdef FMT_USE_INT128
 // Do nothing.
-#elif defined(__SIZEOF_INT128__) && !FMT_NVCC && \
-    !(FMT_CLANG_VERSION && FMT_MSC_VER)
+#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
+    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
 #  define FMT_USE_INT128 1
-using int128_t = __int128_t;
-using uint128_t = __uint128_t;
+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;
 }
@@ -411,27 +396,24 @@
 #  define FMT_USE_INT128 0
 #endif
 #if !FMT_USE_INT128
-enum class int128_t {};
-enum class uint128_t {};
+enum class int128_opt {};
+enum class uint128_opt {};
 // Reduce template instantiations.
-template <typename T> inline auto convert_for_visit(T) -> monostate {
-  return {};
-}
+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(value >= 0, "negative value");
+  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
   return static_cast<typename std::make_unsigned<Int>::type>(value);
 }
 
 FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char micro[] = "\u00B5";
 
 constexpr auto is_utf8() -> bool {
-  // Avoid buggy sign extensions in MSVC's constant evaluation mode.
-  // https://developercommunity.visualstudio.com/t/C-difference-in-behavior-for-unsigned/1233612
+  // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297).
   using uchar = unsigned char;
   return FMT_UNICODE || (sizeof(micro) == 3 && uchar(micro[0]) == 0xC2 &&
                          uchar(micro[1]) == 0xB5);
@@ -454,12 +436,11 @@
   using value_type = Char;
   using iterator = const Char*;
 
-  constexpr basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
+  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) FMT_NOEXCEPT
-      : data_(s),
-        size_(count) {}
+  constexpr basic_string_view(const Char* s, size_t count) noexcept
+      : data_(s), size_(count) {}
 
   /**
     \rst
@@ -479,29 +460,28 @@
   /** 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) FMT_NOEXCEPT
-      : data_(s.data()),
-        size_(s.size()) {}
+      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) FMT_NOEXCEPT : data_(s.data()),
-                                                      size_(s.size()) {}
+  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 FMT_NOEXCEPT -> const Char* { return data_; }
+  constexpr auto data() const noexcept -> const Char* { return data_; }
 
   /** Returns the string size. */
-  constexpr auto size() const FMT_NOEXCEPT -> size_t { return size_; }
+  constexpr auto size() const noexcept -> size_t { return size_; }
 
-  constexpr auto begin() const FMT_NOEXCEPT -> iterator { return data_; }
-  constexpr auto end() const FMT_NOEXCEPT -> iterator { return data_ + 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 FMT_NOEXCEPT -> const Char& {
+  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
     return data_[pos];
   }
 
-  FMT_CONSTEXPR void remove_prefix(size_t n) FMT_NOEXCEPT {
+  FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
     data_ += n;
     size_ -= n;
   }
@@ -543,6 +523,14 @@
 template <typename T> struct is_char : std::false_type {};
 template <> struct is_char<char> : std::true_type {};
 
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// A base class for compile-time strings.
+struct compile_string {};
+
+template <typename S>
+struct is_compile_string : std::is_base_of<compile_string, S> {};
+
 // Returns a string view of `s`.
 template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
 FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
@@ -559,33 +547,21 @@
   return s;
 }
 template <typename Char,
-          FMT_ENABLE_IF(!std::is_empty<detail::std_string_view<Char>>::value)>
-inline auto to_string_view(detail::std_string_view<Char> s)
-    -> basic_string_view<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;
 }
-
-// A base class for compile-time strings. It is defined in the fmt namespace to
-// make formatting functions visible via ADL, e.g. format(FMT_STRING("{}"), 42).
-struct compile_string {};
-
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, 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);
 }
-
-FMT_BEGIN_DETAIL_NAMESPACE
-
 void to_string_view(...);
-using fmt::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 invocation of to_string_view is DEPRECATED!
 template <typename S>
 struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
 };
@@ -596,17 +572,60 @@
   using type = typename result::value_type;
 };
 
-// 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
+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 bool is_integral_type(type t) {
+  return t > type::none_type && t <= type::last_integer_type;
 }
-template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-void check_format_string(S);
+
+constexpr bool is_arithmetic_type(type t) {
+  return t > type::none_type && t <= type::last_numeric_type;
+}
 
 FMT_NORETURN FMT_API void throw_format_error(const char* message);
 
@@ -615,7 +634,9 @@
   constexpr error_handler(const error_handler&) = default;
 
   // This function is intentionally not constexpr to give a compile-time error.
-  FMT_NORETURN FMT_API void on_error(const char* message);
+  FMT_NORETURN void on_error(const char* message) {
+    throw_format_error(message);
+  }
 };
 FMT_END_DETAIL_NAMESPACE
 
@@ -635,6 +656,8 @@
   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 = typename basic_string_view<Char>::iterator;
@@ -648,16 +671,14 @@
     Returns an iterator to the beginning of the format string range being
     parsed.
    */
-  constexpr auto begin() const FMT_NOEXCEPT -> iterator {
+  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 FMT_NOEXCEPT -> iterator {
-    return format_str_.end();
-  }
+  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }
 
   /** Advances the begin iterator to ``it``. */
   FMT_CONSTEXPR void advance_to(iterator it) {
@@ -669,25 +690,29 @@
     the next argument index and switches to the automatic indexing.
    */
   FMT_CONSTEXPR auto next_arg_id() -> int {
-    // Don't check if the argument id is valid to avoid overhead and because it
-    // will be checked during formatting anyway.
-    if (next_arg_id_ >= 0) return next_arg_id_++;
-    on_error("cannot switch from manual to automatic argument indexing");
-    return 0;
+    if (next_arg_id_ < 0) {
+      on_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) {
-    if (next_arg_id_ > 0)
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    if (next_arg_id_ > 0) {
       on_error("cannot switch from automatic to manual argument indexing");
-    else
-      next_arg_id_ = -1;
+      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_CONSTEXPR void on_error(const char* message) {
     ErrorHandler::on_error(message);
@@ -698,6 +723,65 @@
 
 using format_parse_context = basic_format_parse_context<char>;
 
+FMT_BEGIN_DETAIL_NAMESPACE
+// A parse context with extra data used only in compile-time checks.
+template <typename Char, typename ErrorHandler = detail::error_handler>
+class compile_parse_context
+    : public basic_format_parse_context<Char, ErrorHandler> {
+ private:
+  int num_args_;
+  const type* types_;
+  using base = basic_format_parse_context<Char, ErrorHandler>;
+
+ public:
+  explicit FMT_CONSTEXPR compile_parse_context(
+      basic_string_view<Char> format_str, int num_args, const type* types,
+      ErrorHandler eh = {}, int next_arg_id = 0)
+      : base(format_str, eh, 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_) this->on_error("argument not found");
+    return id;
+  }
+
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    base::check_arg_id(id);
+    if (id >= num_args_) this->on_error("argument not found");
+  }
+  using base::check_arg_id;
+
+  FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {
+    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
+      this->on_error("width/precision is not integer");
+  }
+};
+FMT_END_DETAIL_NAMESPACE
+
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void
+basic_format_parse_context<Char, ErrorHandler>::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 >= 1200) {
+    using context = detail::compile_parse_context<Char, ErrorHandler>;
+    if (id >= static_cast<context*>(this)->num_args())
+      on_error("argument not found");
+  }
+}
+
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void
+basic_format_parse_context<Char, ErrorHandler>::check_dynamic_spec(int arg_id) {
+  if (detail::is_constant_evaluated()) {
+    using context = detail::compile_parse_context<Char, ErrorHandler>;
+    static_cast<context*>(this)->check_dynamic_spec(arg_id);
+  }
+}
+
 template <typename Context> class basic_format_arg;
 template <typename Context> class basic_format_args;
 template <typename Context> class dynamic_format_arg_store;
@@ -744,10 +828,10 @@
 template <typename Container>
 inline auto get_container(std::back_insert_iterator<Container> it)
     -> Container& {
-  using bi_iterator = std::back_insert_iterator<Container>;
-  struct accessor : bi_iterator {
-    accessor(bi_iterator iter) : bi_iterator(iter) {}
-    using bi_iterator::container;
+  using base = std::back_insert_iterator<Container>;
+  struct accessor : base {
+    accessor(base b) : base(b) {}
+    using base::container;
   };
   return *accessor(it).container;
 }
@@ -784,18 +868,16 @@
  protected:
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
   FMT_MSC_WARNING(suppress : 26495)
-  buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
+  buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
 
-  FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0,
-                         size_t cap = 0) FMT_NOEXCEPT : ptr_(p),
-                                                        size_(sz),
-                                                        capacity_(cap) {}
+  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) FMT_NOEXCEPT {
+  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
     ptr_ = buf_data;
     capacity_ = buf_capacity;
   }
@@ -810,23 +892,23 @@
   buffer(const buffer&) = delete;
   void operator=(const buffer&) = delete;
 
-  auto begin() FMT_NOEXCEPT -> T* { return ptr_; }
-  auto end() FMT_NOEXCEPT -> T* { return ptr_ + size_; }
+  auto begin() noexcept -> T* { return ptr_; }
+  auto end() noexcept -> T* { return ptr_ + size_; }
 
-  auto begin() const FMT_NOEXCEPT -> const T* { return ptr_; }
-  auto end() const FMT_NOEXCEPT -> const T* { return ptr_ + size_; }
+  auto begin() const noexcept -> const T* { return ptr_; }
+  auto end() const noexcept -> const T* { return ptr_ + size_; }
 
   /** Returns the size of this buffer. */
-  constexpr auto size() const FMT_NOEXCEPT -> size_t { return size_; }
+  constexpr auto size() const noexcept -> size_t { return size_; }
 
   /** Returns the capacity of this buffer. */
-  constexpr auto capacity() const FMT_NOEXCEPT -> size_t { return capacity_; }
+  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
 
   /** Returns a pointer to the buffer data. */
-  FMT_CONSTEXPR auto data() FMT_NOEXCEPT -> T* { return ptr_; }
+  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
 
   /** Returns a pointer to the buffer data. */
-  FMT_CONSTEXPR auto data() const FMT_NOEXCEPT -> const T* { return ptr_; }
+  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
 
   /** Clears this buffer. */
   void clear() { size_ = 0; }
@@ -854,11 +936,11 @@
   /** Appends data to the end of the buffer. */
   template <typename U> void append(const U* begin, const U* end);
 
-  template <typename I> FMT_CONSTEXPR auto operator[](I index) -> T& {
+  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
     return ptr_[index];
   }
-  template <typename I>
-  FMT_CONSTEXPR auto operator[](I index) const -> const T& {
+  template <typename Idx>
+  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
     return ptr_[index];
   }
 };
@@ -993,6 +1075,7 @@
       : 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_);
   }
@@ -1044,7 +1127,11 @@
 // Specifies if T has an enabled fallback_formatter specialization.
 template <typename T, typename Char>
 using has_fallback_formatter =
+#ifdef FMT_DEPRECATED_OSTREAM
     std::is_constructible<fallback_formatter<T, Char>>;
+#else
+    std::false_type;
+#endif
 
 struct view {};
 
@@ -1128,61 +1215,6 @@
   return count<is_statically_named_arg<Args>::value...>();
 }
 
-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_t, int128_type);
-FMT_TYPE_CONSTANT(uint128_t, 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 bool is_integral_type(type t) {
-  return t > type::none_type && t <= type::last_integer_type;
-}
-
-constexpr bool is_arithmetic_type(type t) {
-  return t > type::none_type && t <= type::last_numeric_type;
-}
-
 struct unformattable {};
 struct unformattable_char : unformattable {};
 struct unformattable_const : unformattable {};
@@ -1215,8 +1247,8 @@
     unsigned uint_value;
     long long long_long_value;
     unsigned long long ulong_long_value;
-    int128_t int128_value;
-    uint128_t uint128_value;
+    int128_opt int128_value;
+    uint128_opt uint128_value;
     bool bool_value;
     char_type char_value;
     float float_value;
@@ -1233,8 +1265,8 @@
   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_t val) : int128_value(val) {}
-  FMT_INLINE value(uint128_t val) : uint128_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) {}
@@ -1284,7 +1316,7 @@
 };
 
 template <typename Context, typename T>
-FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context>;
+FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context>;
 
 // 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.
@@ -1292,6 +1324,21 @@
 using long_type = conditional_t<long_short, int, long long>;
 using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
 
+#ifdef __cpp_lib_byte
+inline auto format_as(std::byte b) -> unsigned char {
+  return static_cast<unsigned char>(b);
+}
+#endif
+
+template <typename T> struct has_format_as {
+  template <typename U, typename V = decltype(format_as(U())),
+            FMT_ENABLE_IF(std::is_enum<U>::value&& std::is_integral<V>::value)>
+  static auto check(U*) -> std::true_type;
+  static auto check(...) -> std::false_type;
+
+  enum { value = decltype(check(static_cast<T*>(nullptr)))::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.
@@ -1317,8 +1364,12 @@
       -> unsigned long long {
     return val;
   }
-  FMT_CONSTEXPR FMT_INLINE auto map(int128_t val) -> int128_t { return val; }
-  FMT_CONSTEXPR FMT_INLINE auto map(uint128_t val) -> uint128_t { 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 ||
@@ -1365,45 +1416,24 @@
   }
   template <typename T,
             FMT_ENABLE_IF(
-                std::is_constructible<basic_string_view<char_type>, T>::value &&
+                std::is_convertible<T, basic_string_view<char_type>>::value &&
                 !is_string<T>::value && !has_formatter<T, Context>::value &&
                 !has_fallback_formatter<T, char_type>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
       -> basic_string_view<char_type> {
     return basic_string_view<char_type>(val);
   }
-  template <
-      typename T,
-      FMT_ENABLE_IF(
-          std::is_constructible<std_string_view<char_type>, T>::value &&
-          !std::is_constructible<basic_string_view<char_type>, T>::value &&
-          !is_string<T>::value && !has_formatter<T, Context>::value &&
-          !has_fallback_formatter<T, char_type>::value)>
+  template <typename T,
+            FMT_ENABLE_IF(
+                std::is_convertible<T, std_string_view<char_type>>::value &&
+                !std::is_convertible<T, basic_string_view<char_type>>::value &&
+                !is_string<T>::value && !has_formatter<T, Context>::value &&
+                !has_fallback_formatter<T, char_type>::value)>
   FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
       -> basic_string_view<char_type> {
     return std_string_view<char_type>(val);
   }
 
-  using cstring_result = conditional_t<std::is_same<char_type, char>::value,
-                                       const char*, unformattable_pointer>;
-
-  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const signed char* val)
-      -> cstring_result {
-    return map(reinterpret_cast<const char*>(val));
-  }
-  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const unsigned char* val)
-      -> cstring_result {
-    return map(reinterpret_cast<const char*>(val));
-  }
-  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(signed char* val)
-      -> cstring_result {
-    return map(reinterpret_cast<const char*>(val));
-  }
-  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(unsigned char* val)
-      -> cstring_result {
-    return map(reinterpret_cast<const char*>(val));
-  }
-
   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;
@@ -1417,10 +1447,11 @@
   template <
       typename T,
       FMT_ENABLE_IF(
-          std::is_member_pointer<T>::value ||
+          std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
           std::is_function<typename std::remove_pointer<T>::type>::value ||
           (std::is_convertible<const T&, const void*>::value &&
-           !std::is_convertible<const T&, const char_type*>::value))>
+           !std::is_convertible<const T&, const char_type*>::value &&
+           !has_formatter<T, Context>::value))>
   FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer {
     return {};
   }
@@ -1434,16 +1465,19 @@
   template <typename T,
             FMT_ENABLE_IF(
                 std::is_enum<T>::value&& std::is_convertible<T, int>::value &&
-                !has_formatter<T, Context>::value &&
+                !has_format_as<T>::value && !has_formatter<T, Context>::value &&
                 !has_fallback_formatter<T, char_type>::value)>
-  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+  FMT_DEPRECATED FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
       -> decltype(std::declval<arg_mapper>().map(
-          static_cast<typename std::underlying_type<T>::type>(val))) {
-    return map(static_cast<typename std::underlying_type<T>::type>(val));
+          static_cast<underlying_t<T>>(val))) {
+    return map(static_cast<underlying_t<T>>(val));
   }
 
-  FMT_CONSTEXPR FMT_INLINE auto map(detail::byte val) -> unsigned {
-    return map(static_cast<unsigned char>(val));
+  template <typename T, FMT_ENABLE_IF(has_format_as<T>::value &&
+                                      !has_formatter<T, Context>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> decltype(std::declval<arg_mapper>().map(format_as(T()))) {
+    return map(format_as(val));
   }
 
   template <typename T, typename U = remove_cvref_t<T>>
@@ -1452,8 +1486,9 @@
                       !std::is_const<remove_reference_t<T>>::value ||
                       has_fallback_formatter<U, char_type>::value> {};
 
-#if FMT_MSC_VER != 0 && FMT_MSC_VER < 1910
-  // Workaround a bug in MSVC.
+#if (FMT_MSC_VERSION != 0 && FMT_MSC_VERSION < 1910) || \
+    FMT_ICC_VERSION != 0 || defined(__NVCC__)
+  // Workaround a bug in MSVC and Intel (Issue 2746).
   template <typename T> FMT_CONSTEXPR FMT_INLINE auto do_map(T&& val) -> T& {
     return val;
   }
@@ -1471,6 +1506,8 @@
   template <typename T, typename U = remove_cvref_t<T>,
             FMT_ENABLE_IF(!is_string<U>::value && !is_char<U>::value &&
                           !std::is_array<U>::value &&
+                          !std::is_pointer<U>::value &&
+                          !has_format_as<U>::value &&
                           (has_formatter<U, Context>::value ||
                            has_fallback_formatter<U, char_type>::value))>
   FMT_CONSTEXPR FMT_INLINE auto map(T&& val)
@@ -1513,12 +1550,11 @@
 
  public:
   using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
-  appender(base it) FMT_NOEXCEPT : base(it) {}
-  using _Unchecked_type = appender;  // Mark iterator as checked.
+  appender(base it) noexcept : base(it) {}
+  FMT_UNCHECKED_ITERATOR(appender);
 
-  auto operator++() FMT_NOEXCEPT -> appender& { return *this; }
-
-  auto operator++(int) FMT_NOEXCEPT -> appender { return *this; }
+  auto operator++() noexcept -> appender& { return *this; }
+  auto operator++(int) noexcept -> appender { return *this; }
 };
 
 // A formatting argument. It is a trivially copyable/constructible type to
@@ -1529,7 +1565,7 @@
   detail::type type_;
 
   template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR auto detail::make_arg(const T& value)
+  friend FMT_CONSTEXPR auto detail::make_arg(T&& value)
       -> basic_format_arg<ContextType>;
 
   template <typename Visitor, typename Ctx>
@@ -1564,7 +1600,7 @@
 
   constexpr basic_format_arg() : type_(detail::type::none_type) {}
 
-  constexpr explicit operator bool() const FMT_NOEXCEPT {
+  constexpr explicit operator bool() const noexcept {
     return type_ != detail::type::none_type;
   }
 
@@ -1632,6 +1668,11 @@
   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... Ts> struct void_t_impl { using type = void; };
@@ -1665,7 +1706,7 @@
 template <>
 struct is_contiguous_back_insert_iterator<appender> : std::true_type {};
 
-// A type-erased reference to an std::locale to avoid heavy <locale> include.
+// 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.
@@ -1674,7 +1715,7 @@
   constexpr locale_ref() : locale_(nullptr) {}
   template <typename Locale> explicit locale_ref(const Locale& loc);
 
-  explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
+  explicit operator bool() const noexcept { return locale_ != nullptr; }
 
   template <typename Locale> auto get() const -> Locale;
 };
@@ -1690,20 +1731,8 @@
 }
 
 template <typename Context, typename T>
-FMT_CONSTEXPR auto make_arg(const T& value) -> basic_format_arg<Context> {
-  basic_format_arg<Context> arg;
-  arg.type_ = mapped_type_constant<T, Context>::value;
-  arg.value_ = arg_mapper<Context>().map(value);
-  return arg;
-}
-
-// The type template parameter is there to avoid an ODR violation when using
-// a fallback formatter in one translation unit and an implicit conversion in
-// another (not recommended).
-template <bool IS_PACKED, typename Context, type, typename T,
-          FMT_ENABLE_IF(IS_PACKED)>
-FMT_CONSTEXPR FMT_INLINE auto make_arg(T&& val) -> value<Context> {
-  const auto& arg = arg_mapper<Context>().map(std::forward<T>(val));
+FMT_CONSTEXPR FMT_INLINE auto make_value(T&& val) -> value<Context> {
+  const auto& arg = arg_mapper<Context>().map(FMT_FORWARD(val));
 
   constexpr bool formattable_char =
       !std::is_same<decltype(arg), const unformattable_char&>::value;
@@ -1731,9 +1760,26 @@
   return {arg};
 }
 
+template <typename Context, typename T>
+FMT_CONSTEXPR auto make_arg(T&& value) -> basic_format_arg<Context> {
+  basic_format_arg<Context> arg;
+  arg.type_ = mapped_type_constant<T, Context>::value;
+  arg.value_ = make_value<Context>(value);
+  return arg;
+}
+
+// The type template parameter is there to avoid an ODR violation when using
+// a fallback formatter in one translation unit and an implicit conversion in
+// another (not recommended).
+template <bool IS_PACKED, typename Context, type, typename T,
+          FMT_ENABLE_IF(IS_PACKED)>
+FMT_CONSTEXPR FMT_INLINE auto make_arg(T&& val) -> value<Context> {
+  return make_value<Context>(val);
+}
+
 template <bool IS_PACKED, typename Context, type, typename T,
           FMT_ENABLE_IF(!IS_PACKED)>
-inline auto make_arg(const T& value) -> basic_format_arg<Context> {
+FMT_CONSTEXPR inline auto make_arg(T&& value) -> basic_format_arg<Context> {
   return make_arg<Context>(value);
 }
 FMT_END_DETAIL_NAMESPACE
@@ -1853,7 +1899,7 @@
         data_{detail::make_arg<
             is_packed, Context,
             detail::mapped_type_constant<remove_cvref_t<T>, Context>::value>(
-            std::forward<T>(args))...} {
+            FMT_FORWARD(args))...} {
     detail::init_named_args(data_.named_args(), 0, 0, args...);
   }
 };
@@ -1869,7 +1915,7 @@
 template <typename Context = format_context, typename... Args>
 constexpr auto make_format_args(Args&&... args)
     -> format_arg_store<Context, remove_cvref_t<Args>...> {
-  return {std::forward<Args>(args)...};
+  return {FMT_FORWARD(args)...};
 }
 
 /**
@@ -2015,14 +2061,22 @@
 // between clang and gcc on ARM (#1919).
 using format_args = basic_format_args<format_context>;
 
-// We cannot use enum classes as bit fields because of a gcc bug
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.
+// 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 { none, left, right, center, numeric };
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center,
+                                                  numeric};
 }
 using align_t = align::type;
 namespace sign {
-enum type { none, minus, plus, space };
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
 }
 using sign_t = sign::type;
 
@@ -2072,7 +2126,8 @@
   general_upper,   // 'G'
   chr,             // 'c'
   string,          // 's'
-  pointer          // 'p'
+  pointer,         // 'p'
+  debug            // '?'
 };
 
 // Format specifiers for built-in and string types.
@@ -2209,11 +2264,14 @@
 
   FMT_CONSTEXPR auto make_arg_ref(int arg_id) -> arg_ref_type {
     context_.check_arg_id(arg_id);
+    context_.check_dynamic_spec(arg_id);
     return arg_ref_type(arg_id);
   }
 
   FMT_CONSTEXPR auto make_arg_ref(auto_id) -> arg_ref_type {
-    return arg_ref_type(context_.next_arg_id());
+    int arg_id = context_.next_arg_id();
+    context_.check_dynamic_spec(arg_id);
+    return arg_ref_type(arg_id);
   }
 
   FMT_CONSTEXPR auto make_arg_ref(basic_string_view<char_type> arg_id)
@@ -2231,21 +2289,23 @@
 
 // Converts a character to ASCII. Returns a number > 127 on conversion failure.
 template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
-constexpr auto to_ascii(Char value) -> Char {
-  return value;
+constexpr auto to_ascii(Char c) -> Char {
+  return c;
 }
 template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
-constexpr auto to_ascii(Char value) ->
-    typename std::underlying_type<Char>::type {
-  return value;
+constexpr auto to_ascii(Char c) -> underlying_t<Char> {
+  return c;
+}
+
+FMT_CONSTEXPR inline auto code_point_length_impl(char c) -> int {
+  return "\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>(c) >> 3];
 }
 
 template <typename Char>
 FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
   if (const_check(sizeof(Char) != 1)) return 1;
-  auto lengths =
-      "\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";
-  int len = lengths[static_cast<unsigned char>(*begin) >> 3];
+  int len = code_point_length_impl(static_cast<char>(*begin));
 
   // Compute the pointer to the next character early so that the next
   // iteration can start working on the next character. Neither Clang
@@ -2302,7 +2362,7 @@
   FMT_ASSERT(begin != end, "");
   auto align = align::none;
   auto p = begin + code_point_length(begin);
-  if (p >= end) p = begin;
+  if (end - p <= 0) p = begin;
   for (;;) {
     switch (to_ascii(*p)) {
     case '<':
@@ -2488,6 +2548,8 @@
     return presentation_type::string;
   case 'p':
     return presentation_type::pointer;
+  case '?':
+    return presentation_type::debug;
   default:
     return presentation_type::none;
   }
@@ -2635,21 +2697,21 @@
     return;
   }
   struct writer {
-    FMT_CONSTEXPR void operator()(const Char* pbegin, const Char* pend) {
-      if (pbegin == pend) return;
+    FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
+      if (from == to) return;
       for (;;) {
         const Char* p = nullptr;
-        if (!find<IS_CONSTEXPR>(pbegin, pend, Char('}'), p))
-          return handler_.on_text(pbegin, pend);
+        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
+          return handler_.on_text(from, to);
         ++p;
-        if (p == pend || *p != '}')
+        if (p == to || *p != '}')
           return handler_.on_error("unmatched '}' in format string");
-        handler_.on_text(pbegin, p);
-        pbegin = p + 1;
+        handler_.on_text(from, p);
+        from = p + 1;
       }
     }
     Handler& handler_;
-  } write{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.
@@ -2661,50 +2723,29 @@
   }
 }
 
+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 stripped_type = typename strip_named_arg<T>::type;
   using mapped_type = conditional_t<
       mapped_type_constant<T, context>::value != type::custom_type,
-      decltype(arg_mapper<context>().map(std::declval<const T&>())), T>;
+      decltype(arg_mapper<context>().map(std::declval<const T&>())),
+      stripped_type>;
   auto f = conditional_t<has_formatter<mapped_type, context>::value,
                          formatter<mapped_type, char_type>,
-                         fallback_formatter<T, char_type>>();
+                         fallback_formatter<stripped_type, char_type>>();
   return f.parse(ctx);
 }
 
-// A parse context with extra argument id checks. It is only used at compile
-// time because adding checks at runtime would introduce substantial overhead
-// and would be redundant since argument ids are checked when arguments are
-// retrieved anyway.
-template <typename Char, typename ErrorHandler = error_handler>
-class compile_parse_context
-    : public basic_format_parse_context<Char, ErrorHandler> {
- private:
-  int num_args_;
-  using base = basic_format_parse_context<Char, ErrorHandler>;
-
- public:
-  explicit FMT_CONSTEXPR compile_parse_context(
-      basic_string_view<Char> format_str,
-      int num_args = (std::numeric_limits<int>::max)(), ErrorHandler eh = {})
-      : base(format_str, eh), num_args_(num_args) {}
-
-  FMT_CONSTEXPR auto next_arg_id() -> int {
-    int id = base::next_arg_id();
-    if (id >= num_args_) this->on_error("argument not found");
-    return id;
-  }
-
-  FMT_CONSTEXPR void check_arg_id(int id) {
-    base::check_arg_id(id);
-    if (id >= num_args_) this->on_error("argument not found");
-  }
-  using base::check_arg_id;
-};
-
 template <typename ErrorHandler>
 FMT_CONSTEXPR void check_int_type_spec(presentation_type type,
                                        ErrorHandler&& eh) {
@@ -2717,7 +2758,8 @@
 FMT_CONSTEXPR auto check_char_specs(const basic_format_specs<Char>& specs,
                                     ErrorHandler&& eh = {}) -> bool {
   if (specs.type != presentation_type::none &&
-      specs.type != presentation_type::chr) {
+      specs.type != presentation_type::chr &&
+      specs.type != presentation_type::debug) {
     check_int_type_spec(specs.type, eh);
     return false;
   }
@@ -2741,7 +2783,6 @@
   bool upper : 1;
   bool locale : 1;
   bool binary32 : 1;
-  bool fallback : 1;
   bool showpoint : 1;
 };
 
@@ -2792,7 +2833,8 @@
 template <typename ErrorHandler = error_handler>
 FMT_CONSTEXPR auto check_cstring_type_spec(presentation_type type,
                                            ErrorHandler&& eh = {}) -> bool {
-  if (type == presentation_type::none || type == presentation_type::string)
+  if (type == presentation_type::none || type == presentation_type::string ||
+      type == presentation_type::debug)
     return true;
   if (type != presentation_type::pointer) eh.on_error("invalid type specifier");
   return false;
@@ -2801,7 +2843,8 @@
 template <typename ErrorHandler = error_handler>
 FMT_CONSTEXPR void check_string_type_spec(presentation_type type,
                                           ErrorHandler&& eh = {}) {
-  if (type != presentation_type::none && type != presentation_type::string)
+  if (type != presentation_type::none && type != presentation_type::string &&
+      type != presentation_type::debug)
     eh.on_error("invalid type specifier");
 }
 
@@ -2835,7 +2878,8 @@
   FMT_CONSTEXPR void on_sign(sign_t s) {
     require_numeric_argument();
     if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&
-        arg_type_ != type::long_long_type && arg_type_ != type::char_type) {
+        arg_type_ != type::long_long_type && arg_type_ != type::int128_type &&
+        arg_type_ != type::char_type) {
       this->on_error("format specifier requires signed argument");
     }
     Handler::on_sign(s);
@@ -2864,7 +2908,7 @@
 
 constexpr int invalid_arg_index = -1;
 
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#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 (detail::is_statically_named_arg<T>()) {
@@ -2879,7 +2923,7 @@
 
 template <typename... Args, typename Char>
 FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
   if constexpr (sizeof...(Args) > 0)
     return get_arg_index_by_name<0, Args...>(name);
 #endif
@@ -2890,20 +2934,28 @@
 template <typename Char, typename ErrorHandler, typename... Args>
 class format_string_checker {
  private:
+  // 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_context_type = compile_parse_context<Char, ErrorHandler>;
-  enum { num_args = sizeof...(Args) };
+  static constexpr int num_args = sizeof...(Args);
 
   // Format specifier parsing function.
   using parse_func = const Char* (*)(parse_context_type&);
 
   parse_context_type context_;
-  parse_func parse_funcs_[num_args > 0 ? num_args : 1];
+  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
 
  public:
   explicit FMT_CONSTEXPR format_string_checker(
       basic_string_view<Char> format_str, ErrorHandler eh)
-      : context_(format_str, num_args, eh),
-        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+      : context_(format_str, num_args, types_, eh),
+        parse_funcs_{&parse_format_specs<Args, parse_context_type>...},
+        types_{  // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
+            mapped_type_constant<Args,
+                                 basic_format_context<Char*, Char>>::value...} {
+  }
 
   FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
 
@@ -2912,7 +2964,7 @@
     return context_.check_arg_id(id), id;
   }
   FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
     auto index = get_arg_index_by_name<Args...>(id);
     if (index == invalid_arg_index) on_error("named argument is not found");
     return context_.check_arg_id(index), index;
@@ -2937,10 +2989,19 @@
   }
 };
 
+// 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,
-          enable_if_t<(is_compile_string<S>::value), int>>
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
 void check_format_string(S format_str) {
-  FMT_CONSTEXPR auto s = to_string_view(format_str);
+  FMT_CONSTEXPR auto s = basic_string_view<typename S::char_type>(format_str);
   using checker = format_string_checker<typename S::char_type, error_handler,
                                         remove_cvref_t<Args>...>;
   FMT_CONSTEXPR bool invalid_format =
@@ -3038,11 +3099,41 @@
     return it;
   }
 
+  template <detail::type U = detail::type_constant<T, Char>::value,
+            enable_if_t<(U == detail::type::string_type ||
+                         U == detail::type::cstring_type ||
+                         U == detail::type::char_type),
+                        int> = 0>
+  FMT_CONSTEXPR void set_debug_format() {
+    specs_.type = presentation_type::debug;
+  }
+
   template <typename FormatContext>
   FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
       -> decltype(ctx.out());
 };
 
+#define FMT_FORMAT_AS(Type, Base)                                        \
+  template <typename Char>                                               \
+  struct formatter<Type, Char> : formatter<Base, Char> {                 \
+    template <typename FormatContext>                                    \
+    auto format(Type const& val, FormatContext& ctx) const               \
+        -> decltype(ctx.out()) {                                         \
+      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
+    }                                                                    \
+  }
+
+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, long long);
+FMT_FORMAT_AS(unsigned long, unsigned long long);
+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>);
+
 template <typename Char> struct basic_runtime { basic_string_view<Char> str; };
 
 /** A compile-time format string. */
@@ -3078,10 +3169,8 @@
 
 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
 // Workaround broken conversion on older gcc.
-template <typename... Args> using format_string = string_view;
-template <typename S> auto runtime(const S& s) -> basic_string_view<char_t<S>> {
-  return s;
-}
+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>...>;
@@ -3095,9 +3184,7 @@
     fmt::print(fmt::runtime("{:d}"), "I am not a number");
   \endrst
  */
-template <typename S> auto runtime(const S& s) -> basic_runtime<char_t<S>> {
-  return {{s}};
-}
+inline auto runtime(string_view s) -> basic_runtime<char> { return {{s}}; }
 #endif
 
 FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
diff --git a/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format-inl.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format-inl.h
new file mode 100644
index 0000000..abe4ff1
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format-inl.h
@@ -0,0 +1,1721 @@
+// 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 <cctype>
+#include <cerrno>  // errno
+#include <climits>
+#include <cmath>
+#include <cstdarg>
+#include <cstring>  // std::memmove
+#include <cwchar>
+#include <exception>
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
+#endif
+
+#ifdef _WIN32
+#  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)
+    format_to(it, FMT_STRING("{}{}"), message, SEP);
+  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 size, size_t count,
+                         FILE* stream) {
+  std::fwrite(ptr, size, count, stream);
+}
+
+#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> Locale locale_ref::get() const {
+  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 Char decimal_point_impl(locale_ref loc) {
+  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
+}  // namespace detail
+
+#if !FMT_MSC_VERSION
+FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
+#endif
+
+FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
+                                         format_args args) {
+  auto ec = std::error_code(error_code, std::generic_category());
+  return std::system_error(ec, vformat(format_str, args));
+}
+
+namespace detail {
+
+template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
+  return x.f == y.f && x.e == y.e;
+}
+
+// Compilers should be able to optimize this into the ror instruction.
+FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
+  r &= 31;
+  return (n >> r) | (n << (32 - r));
+}
+FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
+  r &= 63;
+  return (n >> r) | (n << (64 - r));
+}
+
+// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
+inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
+#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 result = uint128_fallback();
+  result.lo_ = _umul128(x, y, &result.hi_);
+  return result;
+#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
+}
+
+// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
+namespace dragonbox {
+// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
+inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
+#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 uint128_fallback umul192_upper128(uint64_t x,
+                                         uint128_fallback y) noexcept {
+  uint128_fallback r = umul128(x, y.high());
+  r += umul128_upper64(x, y.low());
+  return r;
+}
+
+// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
+// 64-bit unsigned integer.
+inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
+  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 uint128_fallback umul192_lower128(uint64_t x,
+                                         uint128_fallback y) noexcept {
+  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 uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
+  return x * y;
+}
+
+// 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 int floor_log10_pow2(int e) noexcept {
+  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
+  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
+  return (e * 315653) >> 20;
+}
+
+// Various fast log computations.
+inline int floor_log2_pow10(int e) noexcept {
+  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
+  return (e * 1741647) >> 19;
+}
+inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
+  FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
+  return (e * 631305 - 261663) >> 21;
+}
+
+static 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>
+bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
+  // 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> uint32_t small_division_by_pow10(uint32_t n) noexcept {
+  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 uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
+  // 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 uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
+  // 2361183241434822607 = ceil(2^(64+7)/1000)
+  return umul128_upper64(n, 2361183241434822607ull) >> 7;
+}
+
+// Various subroutines using pow10 cache
+template <class T> struct cache_accessor;
+
+template <> struct cache_accessor<float> {
+  using carrier_uint = float_info<float>::carrier_uint;
+  using cache_entry_type = uint64_t;
+
+  static uint64_t get_cached_power(int k) noexcept {
+    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 compute_mul_result compute_mul(
+      carrier_uint u, const cache_entry_type& cache) noexcept {
+    auto r = umul96_upper64(u, cache);
+    return {static_cast<carrier_uint>(r >> 32),
+            static_cast<carrier_uint>(r) == 0};
+  }
+
+  static uint32_t compute_delta(const cache_entry_type& cache,
+                                int beta) noexcept {
+    return static_cast<uint32_t>(cache >> (64 - 1 - beta));
+  }
+
+  static compute_mul_parity_result compute_mul_parity(
+      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+    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 carrier_uint compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    return static_cast<carrier_uint>(
+        (cache - (cache >> (num_significand_bits<float>() + 2))) >>
+        (64 - num_significand_bits<float>() - 1 - beta));
+  }
+
+  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    return static_cast<carrier_uint>(
+        (cache + (cache >> (num_significand_bits<float>() + 1))) >>
+        (64 - num_significand_bits<float>() - 1 - beta));
+  }
+
+  static carrier_uint compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    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 uint128_fallback get_cached_power(int k) noexcept {
+    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 }
+#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 }
+#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 compute_mul_result compute_mul(
+      carrier_uint u, const cache_entry_type& cache) noexcept {
+    auto r = umul192_upper128(u, cache);
+    return {r.high(), r.low() == 0};
+  }
+
+  static uint32_t compute_delta(cache_entry_type const& cache,
+                                int beta) noexcept {
+    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
+  }
+
+  static compute_mul_parity_result compute_mul_parity(
+      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+    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 carrier_uint compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    return (cache.high() -
+            (cache.high() >> (num_significand_bits<double>() + 2))) >>
+           (64 - num_significand_bits<double>() - 1 - beta);
+  }
+
+  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    return (cache.high() +
+            (cache.high() >> (num_significand_bits<double>() + 1))) >>
+           (64 - num_significand_bits<double>() - 1 - beta);
+  }
+
+  static carrier_uint compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept {
+    return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
+            1) /
+           2;
+  }
+};
+
+// Various integer checks
+template <class T>
+bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
+  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) noexcept {
+  FMT_ASSERT(n != 0, "");
+  const uint32_t mod_inv_5 = 0xcccccccd;
+  const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+
+  int s = 0;
+  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));
+
+    const uint32_t mod_inv_5 = 0xcccccccd;
+    const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+
+    int s = 8;
+    while (true) {
+      auto q = rotr(n32 * mod_inv_25, 2);
+      if (q > max_value<uint32_t>() / 100) break;
+      n32 = q;
+      s += 2;
+    }
+    auto q = rotr(n32 * mod_inv_5, 1);
+    if (q <= max_value<uint32_t>() / 10) {
+      n32 = q;
+      s |= 1;
+    }
+
+    n = n32;
+    return s;
+  }
+
+  // If n is not divisible by 10^8, work with n itself.
+  const uint64_t mod_inv_5 = 0xcccccccccccccccd;
+  const uint64_t mod_inv_25 = 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 <class 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> decimal_fp<T> to_decimal(T x) noexcept {
+  // 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
+
+#ifdef _MSC_VER
+FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
+    -> int {
+  auto args = va_list();
+  va_start(args, fmt);
+  int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
+  va_end(args);
+  return result;
+}
+#endif
+}  // namespace detail
+
+template <> struct formatter<detail::bigint> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx)
+      -> format_parse_context::iterator {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const detail::bigint& n, FormatContext& ctx) const ->
+      typename FormatContext::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 = format_to(out, FMT_STRING("{:x}"), value);
+        first = false;
+        continue;
+      }
+      out = format_to(out, FMT_STRING("{:08x}"), value);
+    }
+    if (n.exp_ > 0)
+      out = 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 std::string vformat(string_view fmt, format_args args) {
+  // 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 {
+#ifdef _WIN32
+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(std::FILE* f, string_view text) {
+  auto fd = _fileno(f);
+  if (_isatty(fd)) {
+    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
+    auto written = detail::dword();
+    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
+                              u16.c_str(), static_cast<uint32_t>(u16.size()),
+                              &written, nullptr)) {
+      return true;
+    }
+  }
+  // We return false if the file descriptor was not TTY, or it was but
+  // SetConsoleW failed which can happen if the output has been redirected to
+  // NUL. In both cases when we return false, we should attempt to do regular
+  // write via fwrite or std::ostream::write.
+  return false;
+}
+#endif
+
+FMT_FUNC void print(std::FILE* f, string_view text) {
+#ifdef _WIN32
+  if (write_console(f, text)) return;
+#endif
+  detail::fwrite_fully(text.data(), 1, text.size(), f);
+}
+}  // namespace detail
+
+FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  detail::vformat_to(buffer, format_str, args);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+#ifdef _WIN32
+// Print assuming legacy (non-Unicode) encoding.
+FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
+                                      format_args args) {
+  memory_buffer buffer;
+  detail::vformat_to(buffer, format_str,
+                     basic_format_args<buffer_context<char>>(args));
+  fwrite_fully(buffer.data(), 1, buffer.size(), f);
+}
+#endif
+
+FMT_FUNC void vprint(string_view format_str, format_args args) {
+  vprint(stdout, format_str, 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/wpiutil/src/main/native/fmtlib/include/fmt/format.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format.h
similarity index 62%
rename from wpiutil/src/main/native/fmtlib/include/fmt/format.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format.h
index ee69651..7c607db 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/format.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/format.h
@@ -1,33 +1,33 @@
 /*
- Formatting library for C++
+  Formatting library for C++
 
- Copyright (c) 2012 - present, Victor Zverovich
+  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:
+  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 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.
+  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 ---
+  --- 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.
+  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_
@@ -35,11 +35,11 @@
 
 #include <cmath>         // std::signbit
 #include <cstdint>       // uint32_t
+#include <cstring>       // std::memcpy
 #include <limits>        // std::numeric_limits
 #include <memory>        // std::uninitialized_copy
 #include <stdexcept>     // std::runtime_error
 #include <system_error>  // std::system_error
-#include <utility>       // std::swap
 
 #ifdef __cpp_lib_bit_cast
 #  include <bit>  // std::bitcast
@@ -71,7 +71,7 @@
 #  define FMT_NOINLINE
 #endif
 
-#if FMT_MSC_VER
+#if FMT_MSC_VERSION
 #  define FMT_MSC_DEFAULT = default
 #else
 #  define FMT_MSC_DEFAULT
@@ -79,7 +79,7 @@
 
 #ifndef FMT_THROW
 #  if FMT_EXCEPTIONS
-#    if FMT_MSC_VER || FMT_NVCC
+#    if FMT_MSC_VERSION || defined(__NVCC__)
 FMT_BEGIN_NAMESPACE
 namespace detail {
 template <typename Exception> inline void do_throw(const Exception& x) {
@@ -118,17 +118,10 @@
 #  endif
 #endif
 
-// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
-#if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC
-#  define FMT_DEPRECATED_ALIAS
-#else
-#  define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
-#endif
-
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
 #  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
-       FMT_MSC_VER >= 1900) &&                                         \
+       FMT_MSC_VERSION >= 1900) &&                                     \
       (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
 #    define FMT_USE_USER_DEFINED_LITERALS 1
 #  else
@@ -146,7 +139,7 @@
 
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519.
-#if !FMT_MSC_VER
+#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
@@ -158,22 +151,25 @@
 // __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
+#  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
+#  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_VER
+#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_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(FMT_BUILTIN_CTZLL)
+#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.
@@ -243,15 +239,28 @@
 FMT_END_NAMESPACE
 #endif
 
-#ifdef FMT_HEADER_ONLY
-#  define FMT_HEADER_ONLY_CONSTEXPR20 FMT_CONSTEXPR20
-#else
-#  define FMT_HEADER_ONLY_CONSTEXPR20
-#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
+
 template <typename Streambuf> class formatbuf : public Streambuf {
  private:
   using char_type = typename Streambuf::char_type;
@@ -284,14 +293,14 @@
 };
 
 // Implementation of std::bit_cast for pre-C++20.
-template <typename To, typename From>
+template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
 FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
-  static_assert(sizeof(To) == sizeof(From), "size mismatch");
 #ifdef __cpp_lib_bit_cast
   if (is_constant_evaluated()) return std::bit_cast<To>(from);
 #endif
   auto to = To();
-  std::memcpy(&to, &from, sizeof(to));
+  // The cast suppresses a bogus -Wclass-memaccess on GCC.
+  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
   return to;
 }
 
@@ -310,29 +319,117 @@
 #endif
 }
 
-// A fallback implementation of uintptr_t for systems that lack it.
-struct fallback_uintptr {
-  unsigned char value[sizeof(void*)];
+class uint128_fallback {
+ private:
+  uint64_t lo_, hi_;
 
-  fallback_uintptr() = default;
-  explicit fallback_uintptr(const void* p) {
-    *this = bit_cast<fallback_uintptr>(p);
-    if (const_check(is_big_endian())) {
-      for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
-        std::swap(value[i], value[j]);
+  friend uint128_fallback umul128(uint64_t x, uint64_t y) noexcept;
+
+ 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 uint64_t high() const noexcept { return hi_; }
+  constexpr uint64_t low() const noexcept { 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 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_CONSTEXPR20 uint128_fallback& operator+=(uint64_t n) noexcept {
+    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;
-inline auto to_uintptr(const void* p) -> uintptr_t {
-  return bit_cast<uintptr_t>(p);
-}
 #else
-using uintptr_t = fallback_uintptr;
-inline auto to_uintptr(const void* p) -> fallback_uintptr {
-  return fallback_uintptr(p);
-}
+using uintptr_t = uint128_t;
 #endif
 
 // Returns the largest possible value for type T. Same as
@@ -344,16 +441,31 @@
   return std::numeric_limits<T>::digits;
 }
 // std::numeric_limits<T>::digits may return 0 for 128-bit ints.
-template <> constexpr auto num_bits<int128_t>() -> int { return 128; }
+template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
 template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
-template <> constexpr auto num_bits<fallback_uintptr>() -> int {
-  return static_cast<int>(sizeof(void*) *
-                          std::numeric_limits<unsigned char>::digits);
+
+// 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;
 }
 
 FMT_INLINE void assume(bool condition) {
   (void)condition;
-#if FMT_HAS_BUILTIN(__builtin_assume)
+#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
   __builtin_assume(condition);
 #endif
 }
@@ -495,19 +607,23 @@
   constexpr const int shiftc[] = {0, 18, 12, 6, 0};
   constexpr const int shifte[] = {0, 6, 4, 2, 0};
 
-  int len = code_point_length(s);
-  const char* next = s + len;
+  int len = code_point_length_impl(*s);
+  // 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(s[0] & masks[len]) << 18;
-  *c |= uint32_t(s[1] & 0x3f) << 12;
-  *c |= uint32_t(s[2] & 0x3f) << 6;
-  *c |= uint32_t(s[3] & 0x3f) << 0;
+  *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.
-  using uchar = unsigned char;
   *e = (*c < mins[len]) << 6;       // non-canonical encoding
   *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
   *e |= (*c > 0x10FFFF) << 8;       // out of range?
@@ -531,8 +647,8 @@
     auto error = 0;
     auto end = utf8_decode(buf_ptr, &cp, &error);
     bool result = f(error ? invalid_code_point : cp,
-                    string_view(ptr, to_unsigned(end - buf_ptr)));
-    return result ? end : nullptr;
+                    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.
@@ -595,8 +711,8 @@
 }
 
 inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
-  return compute_width(basic_string_view<char>(
-      reinterpret_cast<const char*>(s.data()), s.size()));
+  return compute_width(
+      string_view(reinterpret_cast<const char*>(s.data()), s.size()));
 }
 
 template <typename Char>
@@ -606,9 +722,8 @@
 }
 
 // Calculates the index of the nth code point in a UTF-8 string.
-inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
-    -> size_t {
-  const char8_type* data = s.data();
+inline auto code_point_index(string_view s, size_t n) -> size_t {
+  const char* data = s.data();
   size_t num_code_points = 0;
   for (size_t i = 0, size = s.size(); i != size; ++i) {
     if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) return i;
@@ -616,11 +731,38 @@
   return s.size();
 }
 
+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);
+}
+
+#ifndef FMT_USE_FLOAT128
+#  ifdef __SIZEOF_FLOAT128__
+#    define FMT_USE_FLOAT128 1
+#  else
+#    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
@@ -698,9 +840,7 @@
       const Allocator& alloc = Allocator())
       : alloc_(alloc) {
     this->set(store_, SIZE);
-    if (detail::is_constant_evaluated()) {
-      detail::fill_n(store_, SIZE, T{});
-    }
+    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
   }
   FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
 
@@ -712,18 +852,14 @@
     size_t size = other.size(), capacity = other.capacity();
     if (data == other.store_) {
       this->set(store_, capacity);
-      if (detail::is_constant_evaluated()) {
-        detail::copy_str<T>(other.store_, other.store_ + size,
-                            detail::make_checked(store_, capacity));
-      } else {
-        std::uninitialized_copy(other.store_, other.store_ + size,
-                                detail::make_checked(store_, capacity));
-      }
+      detail::copy_str<T>(other.store_, other.store_ + size,
+                          detail::make_checked(store_, capacity));
     } 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);
   }
@@ -735,8 +871,7 @@
     of the other object to it.
     \endrst
    */
-  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other)
-      FMT_NOEXCEPT {
+  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept {
     move(other);
   }
 
@@ -745,8 +880,7 @@
     Moves the content of the other ``basic_memory_buffer`` object to this one.
     \endrst
    */
-  auto operator=(basic_memory_buffer&& other) FMT_NOEXCEPT
-      -> basic_memory_buffer& {
+  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
     FMT_ASSERT(this != &other, "");
     deallocate();
     move(other);
@@ -776,9 +910,7 @@
 template <typename T, size_t SIZE, typename Allocator>
 FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
     size_t size) {
-#ifdef FMT_FUZZ
-  if (size > 5000) throw std::runtime_error("fuzz mode - won't grow that much");
-#endif
+  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;
@@ -806,8 +938,11 @@
 };
 
 namespace detail {
+#ifdef _WIN32
+FMT_API bool write_console(std::FILE* f, string_view text);
+#endif
 FMT_API void print(std::FILE*, string_view);
-}
+}  // namespace detail
 
 /** A formatting error such as invalid format string. */
 FMT_CLASS_API
@@ -820,39 +955,17 @@
   format_error& operator=(const format_error&) = default;
   format_error(format_error&&) = default;
   format_error& operator=(format_error&&) = default;
-  ~format_error() FMT_NOEXCEPT override FMT_MSC_DEFAULT;
+  ~format_error() noexcept override FMT_MSC_DEFAULT;
 };
 
-/**
-  \rst
-  Constructs a `~fmt::format_arg_store` object that contains references
-  to arguments and can be implicitly converted to `~fmt::format_args`.
-  If ``fmt`` is a compile-time string then `make_args_checked` checks
-  its validity at compile time.
-  \endrst
- */
-template <typename... Args, typename S, typename Char = char_t<S>>
-FMT_INLINE auto make_args_checked(const S& fmt,
-                                  const remove_reference_t<Args>&... args)
-    -> format_arg_store<buffer_context<Char>, remove_reference_t<Args>...> {
-  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");
-  detail::check_format_string<Args...>(fmt);
-  return {args...};
-}
-
-// compile-time support
 namespace detail_exported {
-#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#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]{};
+  Char data[N] = {};
 };
 #endif
 
@@ -874,30 +987,31 @@
 FMT_BEGIN_DETAIL_NAMESPACE
 
 template <typename T> struct is_integral : std::is_integral<T> {};
-template <> struct is_integral<int128_t> : std::true_type {};
+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_t>::value>;
+                                     std::is_same<T, int128_opt>::value>;
 
 // 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)>
-FMT_CONSTEXPR auto is_negative(T value) -> bool {
+constexpr auto is_negative(T value) -> bool {
   return value < 0;
 }
 template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
-FMT_CONSTEXPR auto is_negative(T) -> bool {
+constexpr auto is_negative(T) -> bool {
   return false;
 }
 
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-FMT_CONSTEXPR auto is_supported_floating_point(T) -> uint16_t {
-  return (std::is_same<T, float>::value && FMT_USE_FLOAT) ||
-         (std::is_same<T, double>::value && FMT_USE_DOUBLE) ||
-         (std::is_same<T, long double>::value && FMT_USE_LONG_DOUBLE);
+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
@@ -948,7 +1062,7 @@
   }
 }
 #if FMT_USE_INT128
-FMT_CONSTEXPR inline auto count_digits(uint128_t n) -> int {
+FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int {
   return count_digits_fallback(n);
 }
 #endif
@@ -989,7 +1103,7 @@
 template <int BITS, typename UInt>
 FMT_CONSTEXPR auto count_digits(UInt n) -> int {
 #ifdef FMT_BUILTIN_CLZ
-  if (num_bits<UInt>() == 32)
+  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.
@@ -1002,8 +1116,6 @@
   }(n);
 }
 
-template <> auto count_digits<4>(detail::fallback_uintptr n) -> int;
-
 #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.
@@ -1039,15 +1151,11 @@
   return count_digits_fallback(n);
 }
 
-template <typename Int> constexpr auto digits10() FMT_NOEXCEPT -> int {
+template <typename Int> constexpr auto digits10() noexcept -> int {
   return std::numeric_limits<Int>::digits10;
 }
-template <> constexpr auto digits10<int128_t>() FMT_NOEXCEPT -> int {
-  return 38;
-}
-template <> constexpr auto digits10<uint128_t>() FMT_NOEXCEPT -> int {
-  return 38;
-}
+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;
@@ -1127,7 +1235,7 @@
 
 template <typename Char, typename UInt, typename Iterator,
           FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
-inline auto format_decimal(Iterator out, UInt value, int size)
+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];
@@ -1142,35 +1250,13 @@
   Char* end = buffer;
   do {
     const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
+    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>
-auto format_uint(Char* buffer, detail::fallback_uintptr n, int num_digits,
-                 bool = false) -> Char* {
-  auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
-  int start = (num_digits + char_digits - 1) / char_digits - 1;
-  if (int start_digits = num_digits % char_digits) {
-    unsigned value = n.value[start--];
-    buffer = format_uint<BASE_BITS>(buffer, value, start_digits);
-  }
-  for (; start >= 0; --start) {
-    unsigned value = n.value[start];
-    buffer += char_digits;
-    auto p = buffer;
-    for (int i = 0; i < char_digits; ++i) {
-      unsigned digit = (value & ((1 << BASE_BITS) - 1));
-      *--p = static_cast<Char>("0123456789abcdef"[digit]);
-      value >>= BASE_BITS;
-    }
-  }
-  return buffer;
-}
-
 template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
 inline auto format_uint(It out, UInt value, int num_digits, bool upper = false)
     -> It {
@@ -1200,58 +1286,45 @@
 namespace dragonbox {
 
 // Type-specific information that Dragonbox uses.
-template <class T> struct float_info;
+template <typename T, typename Enable = void> struct float_info;
 
 template <> struct float_info<float> {
   using carrier_uint = uint32_t;
-  static const int significand_bits = 23;
   static const int exponent_bits = 8;
-  static const int min_exponent = -126;
-  static const int max_exponent = 127;
-  static const int exponent_bias = -127;
-  static const int decimal_digits = 9;
   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 cache_bits = 64;
-  static const int divisibility_check_by_5_threshold = 39;
-  static const int case_fc_pm_half_lower_threshold = -1;
-  static const int case_fc_pm_half_upper_threshold = 6;
-  static const int case_fc_lower_threshold = -2;
-  static const int case_fc_upper_threshold = 6;
-  static const int case_shorter_interval_left_endpoint_lower_threshold = 2;
-  static const int case_shorter_interval_left_endpoint_upper_threshold = 3;
   static const int shorter_interval_tie_lower_threshold = -35;
   static const int shorter_interval_tie_upper_threshold = -35;
-  static const int max_trailing_zeros = 7;
 };
 
 template <> struct float_info<double> {
   using carrier_uint = uint64_t;
-  static const int significand_bits = 52;
   static const int exponent_bits = 11;
-  static const int min_exponent = -1022;
-  static const int max_exponent = 1023;
-  static const int exponent_bias = -1023;
-  static const int decimal_digits = 17;
   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 = 326;
-  static const int cache_bits = 128;
-  static const int divisibility_check_by_5_threshold = 86;
-  static const int case_fc_pm_half_lower_threshold = -2;
-  static const int case_fc_pm_half_upper_threshold = 9;
-  static const int case_fc_lower_threshold = -4;
-  static const int case_fc_upper_threshold = 9;
-  static const int case_shorter_interval_left_endpoint_lower_threshold = 2;
-  static const int case_shorter_interval_left_endpoint_upper_threshold = 3;
   static const int shorter_interval_tie_lower_threshold = -77;
   static const int shorter_interval_tie_upper_threshold = -77;
-  static const int max_trailing_zeros = 16;
+};
+
+// 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 {
@@ -1260,16 +1333,35 @@
   int exponent;
 };
 
-template <typename T>
-FMT_API auto to_decimal(T x) FMT_NOEXCEPT -> decimal_fp<T>;
+template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
 }  // namespace dragonbox
 
-template <typename T>
+// Returns true iff Float has the implicit bit which is not stored.
+template <typename Float> constexpr bool has_implicit_bit() {
+  // 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 int num_significand_bits() {
+  // 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<T>::carrier_uint {
-  using uint = typename dragonbox::float_info<T>::carrier_uint;
-  return ((uint(1) << dragonbox::float_info<T>::exponent_bits) - 1)
-         << dragonbox::float_info<T>::significand_bits;
+    typename dragonbox::float_info<Float>::carrier_uint {
+  using uint = typename dragonbox::float_info<Float>::carrier_uint;
+  return ((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.
@@ -1294,21 +1386,251 @@
   return it;
 }
 
-template <typename T>
-FMT_HEADER_ONLY_CONSTEXPR20 auto format_float(T value, int precision,
-                                              float_specs specs,
-                                              buffer<char>& buf) -> int;
+// A floating-point number f * pow(2, e) where F is an unsigned type.
+template <typename F> struct basic_fp {
+  F f;
+  int e;
 
-// Formats a floating-point number with snprintf.
-template <typename T>
-auto snprintf_float(T value, int precision, float_specs specs,
-                    buffer<char>& buf) -> int;
+  static constexpr const int num_significand_bits =
+      static_cast<int>(sizeof(F) * num_bits<unsigned char>());
 
-template <typename T> constexpr auto promote_float(T value) -> T {
+  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 basic_fp<F> normalize(basic_fp<F> value) {
+  // 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;
 }
-constexpr auto promote_float(float value) -> double {
-  return static_cast<double>(value);
+
+// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
+FMT_CONSTEXPR inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
+#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 fp operator*(fp x, fp y) {
+  return {multiply(x.f, y.f), x.e + y.e + 64};
+}
+
+template <typename T = void> struct basic_data {
+  // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
+  // These are generated by support/compute-powers.py.
+  static constexpr uint64_t pow10_significands[87] = {
+      0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
+      0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
+      0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
+      0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+      0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
+      0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
+      0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
+      0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+      0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
+      0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
+      0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
+      0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+      0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
+      0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
+      0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
+      0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+      0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
+      0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
+      0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
+      0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+      0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
+      0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
+      0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
+      0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+      0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
+      0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
+      0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
+      0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+      0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
+  };
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wnarrowing"
+#endif
+  // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
+  // to significands above.
+  static constexpr int16_t pow10_exponents[87] = {
+      -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
+      -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688, -661,
+      -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396, -369,
+      -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103, -77,
+      -50,   -24,   3,     30,    56,    83,    109,   136,   162,   189,  216,
+      242,   269,   295,   322,   348,   375,   402,   428,   455,   481,  508,
+      534,   561,   588,   614,   641,   667,   694,   720,   747,   774,  800,
+      827,   853,   880,   907,   933,   960,   986,   1013,  1039,  1066};
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+#  pragma GCC diagnostic pop
+#endif
+
+  static constexpr uint64_t power_of_10_64[20] = {
+      1, FMT_POWERS_OF_10(1ULL), FMT_POWERS_OF_10(1000000000ULL),
+      10000000000000000000ULL};
+};
+
+#if FMT_CPLUSPLUS < 201703L
+template <typename T> constexpr uint64_t basic_data<T>::pow10_significands[];
+template <typename T> constexpr int16_t basic_data<T>::pow10_exponents[];
+template <typename T> constexpr uint64_t basic_data<T>::power_of_10_64[];
+#endif
+
+// This is a struct rather than an alias to avoid shadowing warnings in gcc.
+struct data : basic_data<> {};
+
+// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
+// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
+FMT_CONSTEXPR inline fp get_cached_power(int min_exponent,
+                                         int& pow10_exponent) {
+  const int shift = 32;
+  // log10(2) = 0x0.4d104d427de7fbcc...
+  const int64_t significand = 0x4d104d427de7fbcc;
+  int index = static_cast<int>(
+      ((min_exponent + fp::num_significand_bits - 1) * (significand >> shift) +
+       ((int64_t(1) << shift) - 1))  // ceil
+      >> 32                          // arithmetic shift
+  );
+  // Decimal exponent of the first (smallest) cached power of 10.
+  const int first_dec_exp = -348;
+  // Difference between 2 consecutive decimal exponents in cached powers of 10.
+  const int dec_exp_step = 8;
+  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+  pow10_exponent = first_dec_exp + index * dec_exp_step;
+  // Using *(x + index) instead of x[index] avoids an issue with some compilers
+  // using the EDG frontend (e.g. nvhpc/22.3 in C++17 mode).
+  return {*(data::pow10_significands + index),
+          *(data::pow10_exponents + index)};
+}
+
+#ifndef _MSC_VER
+#  define FMT_SNPRINTF snprintf
+#else
+FMT_API auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...) -> int;
+#  define FMT_SNPRINTF fmt_snprintf
+#endif  // _MSC_VER
+
+// Formats a floating-point number with snprintf using the hexfloat format.
+template <typename T>
+auto snprintf_float(T value, int precision, float_specs specs,
+                    buffer<char>& buf) -> int {
+  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+  FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
+  FMT_ASSERT(specs.format == float_format::hex, "");
+  static_assert(!std::is_same<T, float>::value, "");
+
+  // Build the format string.
+  char format[7];  // The longest format is "%#.*Le".
+  char* format_ptr = format;
+  *format_ptr++ = '%';
+  if (specs.showpoint) *format_ptr++ = '#';
+  if (precision >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+  if (std::is_same<T, long double>()) *format_ptr++ = 'L';
+  *format_ptr++ = specs.upper ? 'A' : 'a';
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  auto offset = buf.size();
+  for (;;) {
+    auto begin = buf.data() + offset;
+    auto capacity = buf.capacity() - offset;
+    abort_fuzzing_if(precision > 100000);
+    // Suppress the warning about a nonliteral format string.
+    // Cannot use auto because of a bug in MinGW (#1532).
+    int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
+    int result = precision >= 0
+                     ? snprintf_ptr(begin, capacity, format, precision, value)
+                     : snprintf_ptr(begin, capacity, format, value);
+    if (result < 0) {
+      // The buffer will grow exponentially.
+      buf.try_reserve(buf.capacity() + 1);
+      continue;
+    }
+    auto size = to_unsigned(result);
+    // Size equal to capacity means that the last character was truncated.
+    if (size < capacity) {
+      buf.try_resize(size + offset);
+      return 0;
+    }
+    buf.try_reserve(size + offset + 1);  // Add 1 for the terminating '\0'.
+  }
+}
+
+template <typename T>
+using convert_float_result =
+    conditional_t<std::is_same<T, float>::value || sizeof(T) == sizeof(double),
+                  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>
@@ -1377,11 +1699,172 @@
                : 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_GCC_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 (is_utf8()) {
+      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 {
+  *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, &v + 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 basic_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;
   });
@@ -1519,7 +2002,10 @@
                               grouping.count_separators(num_digits));
   return write_padded<align::right>(
       out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
-        if (prefix != 0) *it++ = static_cast<Char>(prefix);
+        if (prefix != 0) {
+          char sign = static_cast<char>(prefix);
+          *it++ = static_cast<Char>(sign);
+        }
         return grouping.apply(it, string_view(digits, to_unsigned(num_digits)));
       });
 }
@@ -1647,6 +2133,46 @@
   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 size_t count() const { return count_; }
+
+  FMT_CONSTEXPR counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
+  FMT_CONSTEXPR counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  FMT_CONSTEXPR friend counting_iterator operator+(counting_iterator it,
+                                                   difference_type n) {
+    it.count_ += static_cast<size_t>(n);
+    return it;
+  }
+
+  FMT_CONSTEXPR value_type operator*() const { return {}; }
+};
+
 template <typename Char, typename OutputIt>
 FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
                          const basic_format_specs<Char>& specs) -> OutputIt {
@@ -1654,10 +2180,17 @@
   auto size = s.size();
   if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
     size = code_point_index(s, to_unsigned(specs.precision));
-  auto width =
-      specs.width != 0 ? compute_width(basic_string_view<Char>(data, size)) : 0;
+  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);
                       });
 }
@@ -1675,15 +2208,37 @@
     -> OutputIt {
   return check_cstring_type_spec(specs.type)
              ? write(out, basic_string_view<Char>(s), specs, {})
-             : write_ptr<Char>(out, to_uintptr(s), &specs);
+             : write_ptr<Char>(out, bit_cast<uintptr_t>(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);
 }
 
 template <typename Char, typename OutputIt>
-FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isinf,
+FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
                                      basic_format_specs<Char> specs,
                                      const float_specs& fspecs) -> OutputIt {
   auto str =
-      isinf ? (fspecs.upper ? "INF" : "inf") : (fspecs.upper ? "NAN" : "nan");
+      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);
@@ -1704,12 +2259,12 @@
   int exponent;
 };
 
-constexpr auto get_significand_size(const big_decimal_fp& fp) -> int {
-  return fp.significand_size;
+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>& fp) -> int {
-  return count_digits(fp.significand);
+inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
+  return count_digits(f.significand);
 }
 
 template <typename Char, typename OutputIt>
@@ -1747,7 +2302,7 @@
   int floating_size = significand_size - integral_size;
   for (int i = floating_size / 2; i > 0; --i) {
     out -= 2;
-    copy2(out, digits2(significand % 100));
+    copy2(out, digits2(static_cast<std::size_t>(significand % 100)));
     significand /= 100;
   }
   if (floating_size % 2 != 0) {
@@ -1803,13 +2358,13 @@
 
 template <typename OutputIt, typename DecimalFP, typename Char,
           typename Grouping = digit_grouping<Char>>
-FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& fp,
+FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
                                     const basic_format_specs<Char>& specs,
                                     float_specs fspecs, locale_ref loc)
     -> OutputIt {
-  auto significand = fp.significand;
-  int significand_size = get_significand_size(fp);
-  constexpr Char zero = static_cast<Char>('0');
+  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>;
@@ -1817,7 +2372,7 @@
   Char decimal_point =
       fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
 
-  int output_exp = fp.exponent + significand_size - 1;
+  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;
@@ -1855,25 +2410,23 @@
                            : base_iterator(out, write(reserve(out, size)));
   }
 
-  int exp = fp.exponent + significand_size;
-  if (fp.exponent >= 0) {
+  int exp = f.exponent + significand_size;
+  if (f.exponent >= 0) {
     // 1234e5 -> 123400000[.0+]
-    size += to_unsigned(fp.exponent);
+    size += to_unsigned(f.exponent);
     int num_zeros = fspecs.precision - exp;
-#ifdef FMT_FUZZ
-    if (num_zeros > 5000)
-      throw std::runtime_error("fuzz mode - avoiding excessive cpu use");
-#endif
+    abort_fuzzing_if(num_zeros > 5000);
     if (fspecs.showpoint) {
+      ++size;
       if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 1;
-      if (num_zeros > 0) size += to_unsigned(num_zeros) + 1;
+      if (num_zeros > 0) size += to_unsigned(num_zeros);
     }
     auto grouping = Grouping(loc, fspecs.locale);
-    size += to_unsigned(grouping.count_separators(significand_size));
+    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,
-                                   fp.exponent, grouping);
+                                   f.exponent, grouping);
       if (!fspecs.showpoint) return it;
       *it++ = decimal_point;
       return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
@@ -1924,63 +2477,713 @@
 };
 
 template <typename OutputIt, typename DecimalFP, typename Char>
-FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& fp,
+FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
                                  const basic_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, fp, specs, fspecs,
+                          fallback_digit_grouping<Char>>(out, f, specs, fspecs,
                                                          loc);
   } else {
-    return do_write_float(out, fp, specs, fspecs, loc);
+    return do_write_float(out, f, specs, fspecs, loc);
   }
 }
 
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-FMT_CONSTEXPR20 bool isinf(T value) {
-  if (is_constant_evaluated()) {
-#if defined(__cpp_if_constexpr)
-    if constexpr (std::numeric_limits<double>::is_iec559) {
-      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
-      constexpr auto significand_bits =
-          dragonbox::float_info<double>::significand_bits;
-      return (bits & exponent_mask<double>()) &&
-             !(bits & ((uint64_t(1) << significand_bits) - 1));
-    }
-#endif
-  }
-  return std::isinf(value);
+template <typename T> constexpr bool isnan(T value) {
+  return !(value >= value);  // std::isnan doesn't support __float128.
 }
 
-template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+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 bool isfinite(T value) {
-  if (is_constant_evaluated()) {
-#if defined(__cpp_if_constexpr)
-    if constexpr (std::numeric_limits<double>::is_iec559) {
-      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
-      return (bits & exponent_mask<double>()) != exponent_mask<double>();
-    }
-#endif
-  }
+  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 bool isfinite(T value) {
+  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(std::is_floating_point<T>::value)>
+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 & (uint64_t(1) << (num_bits<uint64_t>() - 1))) != 0;
+      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
     }
 #endif
   }
-  return std::signbit(value);
+  return std::signbit(static_cast<double>(value));
+}
+
+enum class round_direction { unknown, up, down };
+
+// Given the divisor (normally a power of 10), the remainder = v % divisor for
+// some number v and the error, returns whether v should be rounded up, down, or
+// whether the rounding direction can't be determined due to error.
+// error should be less than divisor / 2.
+FMT_CONSTEXPR inline round_direction get_round_direction(uint64_t divisor,
+                                                         uint64_t remainder,
+                                                         uint64_t error) {
+  FMT_ASSERT(remainder < divisor, "");  // divisor - remainder won't overflow.
+  FMT_ASSERT(error < divisor, "");      // divisor - error won't overflow.
+  FMT_ASSERT(error < divisor - error, "");  // error * 2 won't overflow.
+  // Round down if (remainder + error) * 2 <= divisor.
+  if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
+    return round_direction::down;
+  // Round up if (remainder - error) * 2 >= divisor.
+  if (remainder >= error &&
+      remainder - error >= divisor - (remainder - error)) {
+    return round_direction::up;
+  }
+  return round_direction::unknown;
+}
+
+namespace digits {
+enum result {
+  more,  // Generate more digits.
+  done,  // Done generating digits.
+  error  // Digit generation cancelled due to an error.
+};
+}
+
+struct gen_digits_handler {
+  char* buf;
+  int size;
+  int precision;
+  int exp10;
+  bool fixed;
+
+  FMT_CONSTEXPR digits::result on_digit(char digit, uint64_t divisor,
+                                        uint64_t remainder, uint64_t error,
+                                        bool integral) {
+    FMT_ASSERT(remainder < divisor, "");
+    buf[size++] = digit;
+    if (!integral && error >= remainder) return digits::error;
+    if (size < precision) return digits::more;
+    if (!integral) {
+      // Check if error * 2 < divisor with overflow prevention.
+      // The check is not needed for the integral part because error = 1
+      // and divisor > (1 << 32) there.
+      if (error >= divisor || error >= divisor - error) return digits::error;
+    } else {
+      FMT_ASSERT(error == 1 && divisor > 2, "");
+    }
+    auto dir = get_round_direction(divisor, remainder, error);
+    if (dir != round_direction::up)
+      return dir == round_direction::down ? digits::done : digits::error;
+    ++buf[size - 1];
+    for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
+      buf[i] = '0';
+      ++buf[i - 1];
+    }
+    if (buf[0] > '9') {
+      buf[0] = '1';
+      if (fixed)
+        buf[size++] = '0';
+      else
+        ++exp10;
+    }
+    return digits::done;
+  }
+};
+
+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;
+}
+
+// Generates output using the Grisu digit-gen algorithm.
+// error: the size of the region (lower, upper) outside of which numbers
+// definitely do not round to value (Delta in Grisu3).
+FMT_INLINE FMT_CONSTEXPR20 auto grisu_gen_digits(fp value, uint64_t error,
+                                                 int& exp,
+                                                 gen_digits_handler& handler)
+    -> digits::result {
+  const fp one(1ULL << -value.e, value.e);
+  // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
+  // zero because it contains a product of two 64-bit numbers with MSB set (due
+  // to normalization) - 1, shifted right by at most 60 bits.
+  auto integral = static_cast<uint32_t>(value.f >> -one.e);
+  FMT_ASSERT(integral != 0, "");
+  FMT_ASSERT(integral == value.f >> -one.e, "");
+  // The fractional part of scaled value (p2 in Grisu) c = value % one.
+  uint64_t fractional = value.f & (one.f - 1);
+  exp = count_digits(integral);  // kappa in Grisu.
+  // Non-fixed formats require at least one digit and no precision adjustment.
+  if (handler.fixed) {
+    adjust_precision(handler.precision, exp + handler.exp10);
+    // Check if precision is satisfied just by leading zeros, e.g.
+    // format("{:.2f}", 0.001) gives "0.00" without generating any digits.
+    if (handler.precision <= 0) {
+      if (handler.precision < 0) return digits::done;
+      // Divide by 10 to prevent overflow.
+      uint64_t divisor = data::power_of_10_64[exp - 1] << -one.e;
+      auto dir = get_round_direction(divisor, value.f / 10, error * 10);
+      if (dir == round_direction::unknown) return digits::error;
+      handler.buf[handler.size++] = dir == round_direction::up ? '1' : '0';
+      return digits::done;
+    }
+  }
+  // Generate digits for the integral part. This can produce up to 10 digits.
+  do {
+    uint32_t digit = 0;
+    auto divmod_integral = [&](uint32_t divisor) {
+      digit = integral / divisor;
+      integral %= divisor;
+    };
+    // This optimization by Milo Yip reduces the number of integer divisions by
+    // one per iteration.
+    switch (exp) {
+    case 10:
+      divmod_integral(1000000000);
+      break;
+    case 9:
+      divmod_integral(100000000);
+      break;
+    case 8:
+      divmod_integral(10000000);
+      break;
+    case 7:
+      divmod_integral(1000000);
+      break;
+    case 6:
+      divmod_integral(100000);
+      break;
+    case 5:
+      divmod_integral(10000);
+      break;
+    case 4:
+      divmod_integral(1000);
+      break;
+    case 3:
+      divmod_integral(100);
+      break;
+    case 2:
+      divmod_integral(10);
+      break;
+    case 1:
+      digit = integral;
+      integral = 0;
+      break;
+    default:
+      FMT_ASSERT(false, "invalid number of digits");
+    }
+    --exp;
+    auto remainder = (static_cast<uint64_t>(integral) << -one.e) + fractional;
+    auto result = handler.on_digit(static_cast<char>('0' + digit),
+                                   data::power_of_10_64[exp] << -one.e,
+                                   remainder, error, true);
+    if (result != digits::more) return result;
+  } while (exp > 0);
+  // Generate digits for the fractional part.
+  for (;;) {
+    fractional *= 10;
+    error *= 10;
+    char digit = static_cast<char>('0' + (fractional >> -one.e));
+    fractional &= one.f - 1;
+    --exp;
+    auto result = handler.on_digit(digit, one.f, fractional, error, false);
+    if (result != digits::more) return result;
+  }
+}
+
+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 bigit operator[](int index) const {
+    return bigits_[to_unsigned(index)];
+  }
+  FMT_CONSTEXPR20 bigit& operator[](int index) {
+    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();
+    std::copy(data, data + size, make_checked(bigits_.data(), size));
+    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 int num_bigits() const {
+    return static_cast<int>(bigits_.size()) + exp_;
+  }
+
+  FMT_NOINLINE FMT_CONSTEXPR20 bigint& operator<<=(int shift) {
+    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 bigint& operator*=(Int value) {
+    FMT_ASSERT(value > 0, "");
+    multiply(uint32_or_64_or_128_t<Int>(value));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR20 int compare(const bigint& lhs, const bigint& rhs) {
+    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 int add_compare(const bigint& lhs1, const bigint& lhs2,
+                                         const bigint& rhs) {
+    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, 0);
+    exp_ -= exp_difference;
+  }
+
+  // Divides this bignum by divisor, assigning the remainder to this and
+  // returning the quotient.
+  FMT_CONSTEXPR20 int divmod_assign(const bigint& divisor) {
+    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;
+  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 (num_digits < 0) {
+    // 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';
+        ++exp10;
+      }
+      return;
+    }
+    ++digit;
+  }
+  buf[num_digits - 1] = static_cast<char>('0' + digit);
+}
+
+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>()) {
+    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.
+    exp = static_cast<int>(
+        std::ceil((f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10));
+    dragon_flags = dragon::fixup;
+  } else if (!is_constant_evaluated() && 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 {
+    // Use Grisu + Dragon4 for the given precision:
+    // https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf.
+    const int min_exp = -60;  // alpha in Grisu.
+    int cached_exp10 = 0;     // K in Grisu.
+    fp normalized = normalize(fp(converted_value));
+    const auto cached_pow = get_cached_power(
+        min_exp - (normalized.e + fp::num_significand_bits), cached_exp10);
+    normalized = normalized * cached_pow;
+    gen_digits_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
+    if (grisu_gen_digits(normalized, 1, exp, handler) != digits::error &&
+        !is_constant_evaluated()) {
+      exp += handler.exp10;
+      buf.try_resize(to_unsigned(handler.size));
+      use_dragon = false;
+    } else {
+      exp += handler.size - cached_exp10 - 1;
+      precision = handler.precision;
+    }
+  }
+  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_ENABLE_IF(std::is_floating_point<T>::value)>
+          FMT_ENABLE_IF(is_floating_point<T>::value)>
 FMT_CONSTEXPR20 auto write(OutputIt out, T value,
                            basic_format_specs<Char> specs, locale_ref loc = {})
     -> OutputIt {
@@ -1995,7 +3198,7 @@
   }
 
   if (!detail::isfinite(value))
-    return write_nonfinite(out, detail::isinf(value), specs, fspecs);
+    return write_nonfinite(out, detail::isnan(value), specs, fspecs);
 
   if (specs.align == align::numeric && fspecs.sign) {
     auto it = reserve(out, 1);
@@ -2008,7 +3211,7 @@
   memory_buffer buffer;
   if (fspecs.format == float_format::hex) {
     if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
-    snprintf_float(promote_float(value), specs.precision, fspecs, buffer);
+    snprintf_float(convert_float(value), specs.precision, fspecs, buffer);
     return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
                                      specs);
   }
@@ -2020,28 +3223,23 @@
       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;
-  if (!is_fast_float<T>()) fspecs.fallback = true;
-  int exp = format_float(promote_float(value), precision, fspecs, buffer);
+  int exp = format_float(convert_float(value), precision, fspecs, buffer);
   fspecs.precision = precision;
-  auto fp = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
-  return write_float(out, fp, specs, fspecs, loc);
+  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_fast_float<T>::value)>
 FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
-  if (is_constant_evaluated()) {
+  if (is_constant_evaluated())
     return write(out, value, basic_format_specs<Char>());
-  }
-
   if (const_check(!is_supported_floating_point(value))) return out;
 
-  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
-  using uint = typename dragonbox::float_info<floaty>::carrier_uint;
-  auto bits = bit_cast<uint>(value);
-
   auto fspecs = float_specs();
   if (detail::signbit(value)) {
     fspecs.sign = sign::minus;
@@ -2049,16 +3247,18 @@
   }
 
   constexpr auto specs = basic_format_specs<Char>();
+  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
+  using uint = typename dragonbox::float_info<floaty>::carrier_uint;
   uint mask = exponent_mask<floaty>();
-  if ((bits & mask) == mask)
-    return write_nonfinite(out, std::isinf(value), specs, fspecs);
+  if ((bit_cast<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(std::is_floating_point<T>::value &&
+          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, basic_format_specs<Char>());
@@ -2085,28 +3285,6 @@
   return write<Char>(out, to_string_view(value));
 }
 
-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);
-}
-
 // FMT_ENABLE_IF() condition separated to workaround an MSVC bug.
 template <
     typename Char, typename OutputIt, typename T,
@@ -2116,8 +3294,7 @@
             type::custom_type,
     FMT_ENABLE_IF(check)>
 FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
-  return write<Char>(
-      out, static_cast<typename std::underlying_type<T>::type>(value));
+  return write<Char>(out, static_cast<underlying_t<T>>(value));
 }
 
 template <typename Char, typename OutputIt, typename T,
@@ -2155,7 +3332,7 @@
            const basic_format_specs<Char>& specs = {}, locale_ref = {})
     -> OutputIt {
   check_pointer_type_spec(specs.type, error_handler());
-  return write_ptr<Char>(out, to_uintptr(value), &specs);
+  return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
 }
 
 // A write overload that handles implicit conversions.
@@ -2163,7 +3340,7 @@
           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 &&
-        !std::is_same<T, Char>::value &&
+        !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
         !std::is_same<const T&,
                       decltype(arg_mapper<Context>().map(value))>::value,
     OutputIt> {
@@ -2356,43 +3533,17 @@
   }
 }
 
-#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_GCC_VISIBILITY_HIDDEN FMT_COMPILE_STRING : base {           \
-      using char_type = 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::compile_string, )
-
 #if FMT_USE_USER_DEFINED_LITERALS
 template <typename Char> struct udl_formatter {
   basic_string_view<Char> str;
 
   template <typename... T>
   auto operator()(T&&... args) const -> std::basic_string<Char> {
-    return vformat(str, fmt::make_args_checked<T...>(str, args...));
+    return vformat(str, fmt::make_format_args<buffer_context<Char>>(args...));
   }
 };
 
-#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#  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 {
@@ -2441,10 +3592,10 @@
 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) FMT_NOEXCEPT;
+                               string_view message) noexcept;
 
 FMT_API void report_error(format_func func, int error_code,
-                          const char* message) FMT_NOEXCEPT;
+                          const char* message) noexcept;
 FMT_END_DETAIL_NAMESPACE
 
 FMT_API auto vsystem_error(int error_code, string_view format_str,
@@ -2490,12 +3641,11 @@
   \endrst
  */
 FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
-                                 const char* message) FMT_NOEXCEPT;
+                                 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) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code, const char* message) noexcept;
 
 /** Fast integer formatter. */
 class format_int {
@@ -2577,28 +3727,6 @@
   return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
 }
 
-#define FMT_FORMAT_AS(Type, Base)                                        \
-  template <typename Char>                                               \
-  struct formatter<Type, Char> : formatter<Base, Char> {                 \
-    template <typename FormatContext>                                    \
-    auto format(Type const& val, FormatContext& ctx) const               \
-        -> decltype(ctx.out()) {                                         \
-      return formatter<Base, Char>::format(static_cast<Base>(val), ctx); \
-    }                                                                    \
-  }
-
-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, long long);
-FMT_FORMAT_AS(unsigned long, unsigned long long);
-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::byte, unsigned char);
-FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
-
 template <typename Char>
 struct formatter<void*, Char> : formatter<const void*, Char> {
   template <typename FormatContext>
@@ -2688,6 +3816,28 @@
   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_;
@@ -2779,9 +3929,6 @@
 };
 
 template <typename It, typename Sentinel, typename Char>
-using arg_join FMT_DEPRECATED_ALIAS = join_view<It, Sentinel, Char>;
-
-template <typename It, typename Sentinel, typename Char>
 struct formatter<join_view<It, Sentinel, Char>, Char> {
  private:
   using value_type =
@@ -2818,8 +3965,8 @@
   }
 
   template <typename FormatContext>
-  auto format(const join_view<It, Sentinel, Char>& value, FormatContext& ctx)
-      -> decltype(ctx.out()) {
+  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) {
@@ -2936,9 +4083,10 @@
     basic_format_parse_context<Char> parse_context;
     buffer_context<Char> context;
 
-    format_handler(buffer_appender<Char> out, basic_string_view<Char> str,
-                   basic_format_args<buffer_context<Char>> args, locale_ref loc)
-        : parse_context(str), context(out, args, loc) {}
+    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));
@@ -2995,20 +4143,6 @@
     -> 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;
-extern template auto format_float<double>(double value, int precision,
-                                          float_specs specs, buffer<char>& buf)
-    -> int;
-extern template auto format_float<long double>(long double value, int precision,
-                                               float_specs specs,
-                                               buffer<char>& buf) -> int;
-void snprintf_float(float, int, float_specs, buffer<char>&) = delete;
-extern template auto snprintf_float<double>(double value, int precision,
-                                            float_specs specs,
-                                            buffer<char>& buf) -> int;
-extern template auto snprintf_float<long double>(long double value,
-                                                 int precision,
-                                                 float_specs specs,
-                                                 buffer<char>& buf) -> int;
 #endif  // FMT_HEADER_ONLY
 
 FMT_END_DETAIL_NAMESPACE
@@ -3025,25 +4159,16 @@
     fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
-#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
-template <detail_exported::fixed_string Str>
-constexpr auto operator""_a()
-    -> detail::udl_arg<remove_cvref_t<decltype(Str.data[0])>,
-                       sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str> {
-  return {};
+#  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
-
-// DEPRECATED!
-// User-defined literal equivalent of fmt::format.
-FMT_DEPRECATED constexpr auto operator"" _format(const char* s, size_t n)
-    -> detail::udl_formatter<char> {
-  return {{s, n}};
-}
 }  // namespace literals
 #endif  // FMT_USE_USER_DEFINED_LITERALS
 
@@ -3060,14 +4185,6 @@
   return vformat(loc, string_view(fmt), fmt::make_format_args(args...));
 }
 
-template <typename... T, size_t SIZE, typename Allocator>
-FMT_DEPRECATED auto format_to(basic_memory_buffer<char, SIZE, Allocator>& buf,
-                              format_string<T...> fmt, T&&... args)
-    -> appender {
-  detail::vformat_to(buf, string_view(fmt), fmt::make_format_args(args...));
-  return appender(buf);
-}
-
 template <typename OutputIt, typename Locale,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
                             detail::is_locale<Locale>::value)>
@@ -3090,10 +4207,6 @@
 FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
-#ifdef FMT_DEPRECATED_INCLUDE_XCHAR
-#  include "xchar.h"
-#endif
-
 #ifdef FMT_HEADER_ONLY
 #  define FMT_FUNC inline
 #  include "format-inl.h"
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/os.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/os.h
similarity index 82%
rename from wpiutil/src/main/native/fmtlib/include/fmt/os.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/os.h
index b64f8bb..d82be11 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/os.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/os.h
@@ -9,10 +9,8 @@
 #define FMT_OS_H_
 
 #include <cerrno>
-#include <clocale>  // locale_t
 #include <cstddef>
 #include <cstdio>
-#include <cstdlib>       // strtod_l
 #include <system_error>  // std::system_error
 
 #if defined __APPLE__ || defined(__FreeBSD__)
@@ -141,7 +139,7 @@
 };
 
 #ifdef _WIN32
-FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+FMT_API const std::error_category& system_category() noexcept;
 
 FMT_BEGIN_DETAIL_NAMESPACE
 // A converter from UTF-16 to UTF-8.
@@ -165,7 +163,7 @@
 };
 
 FMT_API void format_windows_error(buffer<char>& out, int error_code,
-                                  const char* message) FMT_NOEXCEPT;
+                                  const char* message) noexcept;
 FMT_END_DETAIL_NAMESPACE
 
 FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
@@ -207,10 +205,9 @@
 
 // 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) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code, const char* message) noexcept;
 #else
-inline const std::error_category& system_category() FMT_NOEXCEPT {
+inline const std::error_category& system_category() noexcept {
   return std::system_category();
 }
 #endif  // _WIN32
@@ -237,13 +234,13 @@
   void operator=(const buffered_file&) = delete;
 
   // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+  buffered_file() noexcept : file_(nullptr) {}
 
   // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() FMT_NOEXCEPT;
+  FMT_API ~buffered_file() noexcept;
 
  public:
-  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
     other.file_ = nullptr;
   }
 
@@ -261,11 +258,9 @@
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-  FILE* get() const FMT_NOEXCEPT { return file_; }
+  FILE* get() const noexcept { return file_; }
 
-  // We place parentheses around fileno to workaround a bug in some versions
-  // of MinGW that define fileno as a macro.
-  FMT_API int(fileno)() const;
+  FMT_API int descriptor() const;
 
   void vprint(string_view format_str, format_args args) {
     fmt::vprint(file_, format_str, args);
@@ -279,12 +274,12 @@
 
 #if FMT_USE_FCNTL
 // A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
+// 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 file {
+class FMT_API file {
  private:
   int fd_;  // File descriptor.
 
@@ -303,16 +298,16 @@
   };
 
   // Constructs a file object which doesn't represent any file.
-  file() FMT_NOEXCEPT : fd_(-1) {}
+  file() noexcept : fd_(-1) {}
 
   // Opens a file and constructs a file object representing this file.
-  FMT_API file(cstring_view path, int oflag);
+  file(cstring_view path, int oflag);
 
  public:
   file(const file&) = delete;
   void operator=(const file&) = delete;
 
-  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
 
   // Move assignment is not noexcept because close may throw.
   file& operator=(file&& other) {
@@ -323,43 +318,43 @@
   }
 
   // Destroys the object closing the file it represents if any.
-  FMT_API ~file() FMT_NOEXCEPT;
+  ~file() noexcept;
 
   // Returns the file descriptor.
-  int descriptor() const FMT_NOEXCEPT { return fd_; }
+  int descriptor() const noexcept { return fd_; }
 
   // Closes the file.
-  FMT_API void close();
+  void close();
 
   // Returns the file size. The size has signed type for consistency with
   // stat::st_size.
-  FMT_API long long size() const;
+  long long size() const;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API size_t read(void* buffer, size_t count);
+  size_t read(void* buffer, size_t count);
 
   // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API size_t write(const void* buffer, size_t count);
+  size_t write(const void* buffer, size_t count);
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.
-  FMT_API static file dup(int fd);
+  static file dup(int fd);
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd);
+  void dup2(int fd);
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
-  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
+  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.
-  FMT_API static void pipe(file& read_end, file& write_end);
+  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.
-  FMT_API buffered_file fdopen(const char* mode);
+  buffered_file fdopen(const char* mode);
 };
 
 // Returns the memory page size.
@@ -462,7 +457,7 @@
 
   * ``<integer>``: Flags passed to `open
     <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
-    (``file::WRONLY | file::CREATE`` by default)
+    (``file::WRONLY | file::CREATE | file::TRUNC`` by default)
   * ``buffer_size=<integer>``: Output buffer size
 
   **Example**::
@@ -477,50 +472,6 @@
 }
 #endif  // FMT_USE_FCNTL
 
-#ifdef FMT_LOCALE
-// A "C" numeric locale.
-class locale {
- private:
-#  ifdef _WIN32
-  using locale_t = _locale_t;
-
-  static void freelocale(locale_t loc) { _free_locale(loc); }
-
-  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
-    return _strtod_l(nptr, endptr, loc);
-  }
-#  endif
-
-  locale_t locale_;
-
- public:
-  using type = locale_t;
-  locale(const locale&) = delete;
-  void operator=(const locale&) = delete;
-
-  locale() {
-#  ifndef _WIN32
-    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
-#  else
-    locale_ = _create_locale(LC_NUMERIC, "C");
-#  endif
-    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
-  }
-  ~locale() { freelocale(locale_); }
-
-  type get() const { return locale_; }
-
-  // Converts string to floating-point number and advances str past the end
-  // of the parsed input.
-  FMT_DEPRECATED double strtod(const char*& str) const {
-    char* end = nullptr;
-    double result = strtod_l(str, &end, locale_);
-    str = end;
-    return result;
-  }
-};
-using Locale FMT_DEPRECATED_ALIAS = locale;
-#endif  // FMT_LOCALE
 FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
diff --git a/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ostream.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ostream.h
new file mode 100644
index 0000000..c3cdd4a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ostream.h
@@ -0,0 +1,237 @@
+// 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>
+#include <ostream>
+#if defined(_WIN32) && defined(__GLIBCXX__)
+#  include <ext/stdio_filebuf.h>
+#  include <ext/stdio_sync_filebuf.h>
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+#  include <__std_stream>
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+namespace detail {
+
+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
+ private:
+  template <typename U>
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
+
+  template <typename> static auto test(...) -> std::false_type;
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    enable_if_t<
+        std::is_arithmetic<T>::value || std::is_array<T>::value ||
+        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
+        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+        std::is_same<T, std_string_view<Char>>::value ||
+        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type {};
+
+// Generate a unique explicit instantion in every translation unit using a tag
+// type in an anonymous namespace.
+namespace {
+struct file_access_tag {};
+}  // namespace
+template <class Tag, class 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*;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+template class file_access<file_access_tag, std::__stdoutbuf<char>,
+                           &std::__stdoutbuf<char>::__file_>;
+auto get_file(std::__stdoutbuf<char>&) -> FILE*;
+#endif
+
+inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+#if FMT_MSC_VERSION
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  FILE* c_file;
+  if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else
+    return false;
+  if (c_file) return write_console(c_file, data);
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#else
+  ignore_unused(os, data);
+#endif
+  return false;
+}
+inline bool write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) {
+  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,
+                  locale_ref loc = locale_ref()) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#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>();
+    format_value(buffer, value, ctx.locale());
+    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>
+auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+namespace detail {
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : basic_ostream_formatter<Char> {
+  using basic_ostream_formatter<Char>::format;
+};
+
+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_MODULE_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_MODULE_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_MODULE_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_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/printf.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/printf.h
similarity index 94%
rename from wpiutil/src/main/native/fmtlib/include/fmt/printf.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/printf.h
index 19d550f..70a592d 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/printf.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/printf.h
@@ -10,7 +10,6 @@
 
 #include <algorithm>  // std::max
 #include <limits>     // std::numeric_limits
-#include <ostream>
 
 #include "format.h"
 
@@ -561,7 +560,7 @@
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> std::basic_string<Char> {
   basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
   return to_string(buffer);
 }
 
@@ -578,7 +577,8 @@
           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> {
   using context = basic_printf_context_t<Char>;
-  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
+  return vsprintf(detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
 }
 
 template <typename S, typename Char = char_t<S>>
@@ -587,7 +587,7 @@
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> int {
   basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
+  vprintf(buffer, detail::to_string_view(fmt), args);
   size_t size = buffer.size();
   return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
@@ -606,7 +606,7 @@
 template <typename S, typename... T, typename Char = char_t<S>>
 inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
   using context = basic_printf_context_t<Char>;
-  return vfprintf(f, to_string_view(fmt),
+  return vfprintf(f, detail::to_string_view(fmt),
                   fmt::make_format_args<context>(args...));
 }
 
@@ -615,7 +615,7 @@
     const S& fmt,
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
     -> int {
-  return vfprintf(stdout, to_string_view(fmt), args);
+  return vfprintf(stdout, detail::to_string_view(fmt), args);
 }
 
 /**
@@ -630,27 +630,10 @@
 template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
 inline auto printf(const S& fmt, const T&... args) -> int {
   return vprintf(
-      to_string_view(fmt),
+      detail::to_string_view(fmt),
       fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
 }
 
-template <typename S, typename Char = char_t<S>>
-FMT_DEPRECATED auto vfprintf(
-    std::basic_ostream<Char>& os, const S& fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
-    -> int {
-  basic_memory_buffer<Char> buffer;
-  vprintf(buffer, to_string_view(fmt), args);
-  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
-  return static_cast<int>(buffer.size());
-}
-template <typename S, typename... T, typename Char = char_t<S>>
-FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
-                            const T&... args) -> int {
-  return vfprintf(os, to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
-}
-
 FMT_MODULE_EXPORT_END
 FMT_END_NAMESPACE
 
diff --git a/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ranges.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ranges.h
new file mode 100644
index 0000000..dea7d60
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/ranges.h
@@ -0,0 +1,722 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#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 RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
+  *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
+  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
+  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>())),
+              enable_if_t<std::is_copy_constructible<T>::value>>>
+    : 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 size_t size() { 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... I>
+  static std::true_type check2(index_sequence<I...>,
+                               integer_sequence<bool, (I == I)...>);
+  static std::false_type check2(...);
+  template <std::size_t... I>
+  static decltype(check2(
+      index_sequence<I...>{},
+      integer_sequence<
+          bool, (is_formattable<typename std::tuple_element<I, T>::type,
+                                C>::value)...>{})) check(index_sequence<I...>);
+
+ public:
+  static constexpr const bool value =
+      decltype(check(tuple_index_sequence<T>{}))::value;
+};
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+#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 Range>
+using uncvref_first_type =
+    remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
+
+template <typename Range>
+using uncvref_second_type = remove_cvref_t<
+    decltype(std::declval<range_reference_type<Range>>().second)>;
+
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
+  return write_escaped_string(out, str);
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
+inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
+  auto sv = std_string_view<Char>(str);
+  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
+}
+
+template <typename Char, typename OutputIt, typename Arg,
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v) {
+  return write_escaped_char(out, v);
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
+
+}  // 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 TupleT, typename Char>
+struct formatter<TupleT, Char,
+                 enable_if_t<fmt::is_tuple_like<TupleT>::value &&
+                             fmt::is_tuple_formattable<TupleT, Char>::value>> {
+ private:
+  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, ')'>{};
+
+  // C++11 generic lambda for format().
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) out = detail::copy_str<Char>(separator, out);
+      out = detail::write_range_entry<Char>(out, v);
+      ++i;
+    }
+    int i;
+    typename FormatContext::iterator& out;
+    basic_string_view<Char> separator;
+  };
+
+ 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()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    detail::for_each(values, format_each<FormatContext>{0, out, separator_});
+    out = detail::copy_str<Char>(closing_bracket_, out);
+    return 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 = conditional_t<
+    is_formattable<Element, Char>::value,
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
+                  std::declval<Element>()))>,
+              Char>,
+    fallback_formatter<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
+    : disjunction<
+          is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
+          has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
+#endif
+
+}  // namespace detail
+
+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>>,
+        disjunction<is_formattable<T, Char>,
+                    detail::has_fallback_formatter<T, Char>>>::value>> {
+ private:
+  detail::range_formatter_type<Char, T> underlying_;
+  bool custom_specs_ = false;
+  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, ']'>{};
+
+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int)
+      -> decltype(u.set_debug_format()) {
+    u.set_debug_format();
+  }
+
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
+  FMT_CONSTEXPR void maybe_set_debug_format() {
+    maybe_set_debug_format(underlying_, 0);
+  }
+
+ 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 == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it == 'n') {
+      set_brackets({}, {});
+      ++it;
+    }
+
+    if (*it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it != ':')
+      FMT_THROW(format_error("no other top-level range formatters supported"));
+
+    custom_specs_ = true;
+    ++it;
+    ctx.advance_to(it);
+    return underlying_.parse(ctx);
+  }
+
+  template <typename R, class 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);
+      out = underlying_.format(mapper.map(*it), 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_ {
+  static constexpr auto value = std::is_same<range_reference_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} {}
+};
+
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+// 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;
+  }
+};
+
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \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_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_RANGES_H_
diff --git a/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/std.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/std.h
new file mode 100644
index 0000000..41d2b28
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/std.h
@@ -0,0 +1,171 @@
+// 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 <thread>
+#include <type_traits>
+#include <utility>
+
+#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
+#endif
+
+#ifdef __cpp_lib_filesystem
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename Char>
+void write_escaped_path(basic_memory_buffer<Char>& quoted,
+                        const std::filesystem::path& p) {
+  write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+}
+#  ifdef _WIN32
+template <>
+inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
+                                     const std::filesystem::path& p) {
+  auto s = p.u8string();
+  write_escaped_string<char>(
+      std::back_inserter(quoted),
+      string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
+}
+#  endif
+template <>
+inline void write_escaped_path<std::filesystem::path::value_type>(
+    basic_memory_buffer<std::filesystem::path::value_type>& quoted,
+    const std::filesystem::path& p) {
+  write_escaped_string<std::filesystem::path::value_type>(
+      std::back_inserter(quoted), p.native());
+}
+
+}  // namespace detail
+
+template <typename Char>
+struct formatter<std::filesystem::path, Char>
+    : formatter<basic_string_view<Char>> {
+  template <typename FormatContext>
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
+      typename FormatContext::iterator {
+    basic_memory_buffer<Char> quoted;
+    detail::write_escaped_path(quoted, p);
+    return formatter<basic_string_view<Char>>::format(
+        basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
+  }
+};
+FMT_END_NAMESPACE
+#endif
+
+FMT_BEGIN_NAMESPACE
+template <typename Char>
+struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
+FMT_END_NAMESPACE
+
+#ifdef __cpp_lib_variant
+FMT_BEGIN_NAMESPACE
+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()) {
+    auto out = ctx.out();
+    out = detail::write<Char>(out, "monostate");
+    return out;
+  }
+};
+
+namespace detail {
+
+template <typename T>
+using variant_index_sequence =
+    std::make_index_sequence<std::variant_size<T>::value>;
+
+// variant_size and variant_alternative check.
+template <typename T, typename U = void>
+struct is_variant_like_ : std::false_type {};
+template <typename T>
+struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
+    : std::true_type {};
+
+// formattable element check
+template <typename T, typename C> class is_variant_formattable_ {
+  template <std::size_t... I>
+  static std::conjunction<
+      is_formattable<std::variant_alternative_t<I, T>, C>...>
+      check(std::index_sequence<I...>);
+
+ 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;
+};
+
+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(");
+    std::visit(
+        [&](const auto& v) {
+          out = detail::write_variant_alternative<Char>(out, v);
+        },
+        value);
+    *out++ = ')';
+    return out;
+  }
+};
+FMT_END_NAMESPACE
+#endif
+
+#endif  // FMT_STD_H_
diff --git a/wpiutil/src/main/native/fmtlib/include/fmt/xchar.h b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/xchar.h
similarity index 80%
rename from wpiutil/src/main/native/fmtlib/include/fmt/xchar.h
rename to wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/xchar.h
index 9acb893..fc3c67f 100644
--- a/wpiutil/src/main/native/fmtlib/include/fmt/xchar.h
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/include/fmt/xchar.h
@@ -9,7 +9,6 @@
 #define FMT_XCHAR_H_
 
 #include <cwchar>
-#include <tuple>
 
 #include "format.h"
 
@@ -30,9 +29,11 @@
 #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) -> basic_runtime<wchar_t> { return {{s}}; }
 #endif
 
 template <> struct is_char<wchar_t> : std::true_type {};
@@ -47,12 +48,7 @@
 }
 
 inline namespace literals {
-constexpr auto operator"" _format(const wchar_t* s, size_t n)
-    -> detail::udl_formatter<wchar_t> {
-  return {{s, n}};
-}
-
-#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
 constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
   return {s};
 }
@@ -87,13 +83,19 @@
   return to_string(buffer);
 }
 
+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... Args, typename Char = char_t<S>,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
+                        !std::is_same<Char, wchar_t>::value)>
 auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat(to_string_view(format_str), vargs);
+  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>,
@@ -103,7 +105,7 @@
     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, to_string_view(format_str), args);
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
 }
 
 template <typename Locale, typename S, typename... Args,
@@ -112,8 +114,8 @@
                             detail::is_exotic_char<Char>::value)>
 inline auto format(const Locale& loc, const S& format_str, Args&&... args)
     -> std::basic_string<Char> {
-  return detail::vformat(loc, to_string_view(format_str),
-                         fmt::make_args_checked<Args...>(format_str, args...));
+  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>,
@@ -123,7 +125,7 @@
                 basic_format_args<buffer_context<type_identity_t<Char>>> args)
     -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, to_string_view(format_str), args);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
   return detail::get_iterator(buf);
 }
 
@@ -132,18 +134,8 @@
           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, Args&&... args) -> OutputIt {
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  return vformat_to(out, to_string_view(fmt), vargs);
-}
-
-template <typename S, typename... Args, typename Char, size_t SIZE,
-          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
-FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
-                              const S& format_str, Args&&... args) ->
-    typename buffer_context<Char>::iterator {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
-  return detail::buffer_appender<Char>(buf);
+  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,
@@ -155,7 +147,8 @@
     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, to_string_view(format_str), args, detail::locale_ref(loc));
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
   return detail::get_iterator(buf);
 }
 
@@ -167,8 +160,8 @@
 inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
                       Args&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
-  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
-  return vformat_to(out, loc, to_string_view(format_str), vargs);
+  return vformat_to(out, loc, to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 template <typename OutputIt, typename Char, typename... Args,
@@ -190,16 +183,16 @@
                             detail::is_exotic_char<Char>::value)>
 inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
                         const Args&... args) -> format_to_n_result<OutputIt> {
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 template <typename S, typename... Args, typename Char = char_t<S>,
           FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
 inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
   detail::counting_buffer<Char> buf;
-  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
-  detail::vformat_to(buf, to_string_view(fmt), vargs);
+  detail::vformat_to(buf, detail::to_string_view(fmt),
+                     fmt::make_format_args<buffer_context<Char>>(args...));
   return buf.count();
 }
 
diff --git a/wpiutil/src/main/native/thirdparty/fmtlib/src/format.cpp b/wpiutil/src/main/native/thirdparty/fmtlib/src/format.cpp
new file mode 100644
index 0000000..99b7e9d
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/src/format.cpp
@@ -0,0 +1,47 @@
+// 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*);
+
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
+template FMT_API void vformat_to(buffer<char>&, string_view,
+                                 basic_format_args<FMT_BUFFER_CONTEXT(char)>,
+                                 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/wpiutil/src/main/native/fmtlib/src/os.cpp b/wpiutil/src/main/native/thirdparty/fmtlib/src/os.cpp
similarity index 90%
rename from wpiutil/src/main/native/fmtlib/src/os.cpp
rename to wpiutil/src/main/native/thirdparty/fmtlib/src/os.cpp
index 4eb3e1f..2c49951 100644
--- a/wpiutil/src/main/native/fmtlib/src/os.cpp
+++ b/wpiutil/src/main/native/thirdparty/fmtlib/src/os.cpp
@@ -35,9 +35,15 @@
 #    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
 
@@ -45,10 +51,6 @@
 #  include <windows.h>
 #endif
 
-#ifdef fileno
-#  undef fileno
-#endif
-
 namespace {
 #ifdef _WIN32
 // Return type of read and write functions.
@@ -107,7 +109,7 @@
   unsigned long result_;
   wchar_t* message_;
 
-  static bool is_whitespace(wchar_t c) FMT_NOEXCEPT {
+  static bool is_whitespace(wchar_t c) noexcept {
     return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
   }
 
@@ -126,15 +128,15 @@
     }
   }
   ~system_message() { LocalFree(message_); }
-  explicit operator bool() const FMT_NOEXCEPT { return result_ != 0; }
-  operator basic_string_view<wchar_t>() const FMT_NOEXCEPT {
+  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 FMT_NOEXCEPT override { return "system"; }
+  const char* name() const noexcept override { return "system"; }
   std::string message(int error_code) const override {
     system_message msg(error_code);
     if (msg) {
@@ -149,7 +151,7 @@
 
 }  // namespace detail
 
-FMT_API const std::error_category& system_category() FMT_NOEXCEPT {
+FMT_API const std::error_category& system_category() noexcept {
   static const detail::utf8_system_category category;
   return category;
 }
@@ -161,13 +163,13 @@
 }
 
 void detail::format_windows_error(detail::buffer<char>& out, int error_code,
-                                  const char* message) FMT_NOEXCEPT {
+                                  const char* message) noexcept {
   FMT_TRY {
     system_message msg(error_code);
     if (msg) {
       utf16_to_utf8 utf8_message;
       if (utf8_message.convert(msg) == ERROR_SUCCESS) {
-        format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
+        fmt::format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
         return;
       }
     }
@@ -176,12 +178,12 @@
   format_error_code(out, error_code, message);
 }
 
-void report_windows_error(int error_code, const char* message) FMT_NOEXCEPT {
+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() FMT_NOEXCEPT {
+buffered_file::~buffered_file() noexcept {
   if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
     report_system_error(errno, "cannot close file");
 }
@@ -200,11 +202,8 @@
   if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
 }
 
-// A macro used to prevent expansion of fileno on broken versions of MinGW.
-#define FMT_ARGS
-
-int buffered_file::fileno() const {
-  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
+int buffered_file::descriptor() const {
+  int fd = FMT_POSIX_CALL(fileno(file_));
   if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
   return fd;
 }
@@ -214,7 +213,8 @@
 #  ifdef _WIN32
   using mode_t = int;
 #  endif
-  mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+  constexpr mode_t mode =
+      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 #  if defined(_WIN32) && !defined(__MINGW32__)
   fd_ = -1;
   FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
@@ -225,7 +225,7 @@
     FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
 }
 
-file::~file() FMT_NOEXCEPT {
+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)
@@ -298,7 +298,7 @@
   }
 }
 
-void file::dup2(int fd, std::error_code& ec) FMT_NOEXCEPT {
+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());
diff --git a/wpiutil/src/main/native/include/wpi/ghc/filesystem.hpp b/wpiutil/src/main/native/thirdparty/ghc/include/wpi/ghc/filesystem.hpp
similarity index 100%
rename from wpiutil/src/main/native/include/wpi/ghc/filesystem.hpp
rename to wpiutil/src/main/native/thirdparty/ghc/include/wpi/ghc/filesystem.hpp
diff --git a/wpiutil/src/main/native/cpp/json.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json.cpp
similarity index 100%
rename from wpiutil/src/main/native/cpp/json.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json.cpp
diff --git a/wpiutil/src/main/native/cpp/json_binary_reader.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json_binary_reader.cpp
similarity index 99%
rename from wpiutil/src/main/native/cpp/json_binary_reader.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json_binary_reader.cpp
index cee5e39..2081359 100644
--- a/wpiutil/src/main/native/cpp/json_binary_reader.cpp
+++ b/wpiutil/src/main/native/thirdparty/json/cpp/json_binary_reader.cpp
@@ -1384,7 +1384,7 @@
     return binary_reader(is).parse_cbor(strict);
 }
 
-json json::from_cbor(span<const uint8_t> arr, const bool strict)
+json json::from_cbor(std::span<const uint8_t> arr, const bool strict)
 {
     raw_mem_istream is(arr);
     return from_cbor(is, strict);
@@ -1395,7 +1395,7 @@
     return binary_reader(is).parse_msgpack(strict);
 }
 
-json json::from_msgpack(span<const uint8_t> arr, const bool strict)
+json json::from_msgpack(std::span<const uint8_t> arr, const bool strict)
 {
     raw_mem_istream is(arr);
     return from_msgpack(is, strict);
@@ -1406,7 +1406,7 @@
     return binary_reader(is).parse_ubjson(strict);
 }
 
-json json::from_ubjson(span<const uint8_t> arr, const bool strict)
+json json::from_ubjson(std::span<const uint8_t> arr, const bool strict)
 {
     raw_mem_istream is(arr);
     return from_ubjson(is, strict);
diff --git a/wpiutil/src/main/native/cpp/json_binary_writer.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json_binary_writer.cpp
similarity index 98%
rename from wpiutil/src/main/native/cpp/json_binary_writer.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json_binary_writer.cpp
index db23f8d..e25d478 100644
--- a/wpiutil/src/main/native/cpp/json_binary_writer.cpp
+++ b/wpiutil/src/main/native/thirdparty/json/cpp/json_binary_writer.cpp
@@ -813,7 +813,7 @@
         std::reverse(vec.begin(), vec.end());
     }
 
-    o << span{vec.data(), sizeof(NumberType)};
+    o << std::span{vec.data(), sizeof(NumberType)};
 }
 
 template<typename NumberType, typename std::enable_if<
@@ -1004,7 +1004,7 @@
     return result;
 }
 
-span<uint8_t> json::to_cbor(const json& j, std::vector<uint8_t>& buf)
+std::span<uint8_t> json::to_cbor(const json& j, std::vector<uint8_t>& buf)
 {
     buf.clear();
     raw_uvector_ostream os(buf);
@@ -1012,7 +1012,7 @@
     return os.array();
 }
 
-span<uint8_t> json::to_cbor(const json& j, SmallVectorImpl<uint8_t>& buf)
+std::span<uint8_t> json::to_cbor(const json& j, SmallVectorImpl<uint8_t>& buf)
 {
     buf.clear();
     raw_usvector_ostream os(buf);
@@ -1033,7 +1033,7 @@
     return result;
 }
 
-span<uint8_t> json::to_msgpack(const json& j, std::vector<uint8_t>& buf)
+std::span<uint8_t> json::to_msgpack(const json& j, std::vector<uint8_t>& buf)
 {
     buf.clear();
     raw_uvector_ostream os(buf);
@@ -1041,7 +1041,7 @@
     return os.array();
 }
 
-span<uint8_t> json::to_msgpack(const json& j, SmallVectorImpl<uint8_t>& buf)
+std::span<uint8_t> json::to_msgpack(const json& j, SmallVectorImpl<uint8_t>& buf)
 {
     buf.clear();
     raw_usvector_ostream os(buf);
@@ -1064,7 +1064,7 @@
     return result;
 }
 
-span<uint8_t> json::to_ubjson(const json& j, std::vector<uint8_t>& buf,
+std::span<uint8_t> json::to_ubjson(const json& j, std::vector<uint8_t>& buf,
                               const bool use_size, const bool use_type)
 {
     buf.clear();
@@ -1073,7 +1073,7 @@
     return os.array();
 }
 
-span<uint8_t> json::to_ubjson(const json& j, SmallVectorImpl<uint8_t>& buf,
+std::span<uint8_t> json::to_ubjson(const json& j, SmallVectorImpl<uint8_t>& buf,
                               const bool use_size, const bool use_type)
 {
     buf.clear();
diff --git a/wpiutil/src/main/native/cpp/json_parser.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json_parser.cpp
similarity index 99%
rename from wpiutil/src/main/native/cpp/json_parser.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json_parser.cpp
index db1ed11..3c29489 100644
--- a/wpiutil/src/main/native/cpp/json_parser.cpp
+++ b/wpiutil/src/main/native/thirdparty/json/cpp/json_parser.cpp
@@ -1921,11 +1921,11 @@
                         const parser_callback_t cb,
                         const bool allow_exceptions)
 {
-    raw_mem_istream is(span<const char>(s.data(), s.size()));
+    raw_mem_istream is(std::span<const char>(s.data(), s.size()));
     return parse(is, cb, allow_exceptions);
 }
 
-json json::parse(span<const uint8_t> arr,
+json json::parse(std::span<const uint8_t> arr,
                         const parser_callback_t cb,
                         const bool allow_exceptions)
 {
@@ -1944,11 +1944,11 @@
 
 bool json::accept(std::string_view s)
 {
-    raw_mem_istream is(span<const char>(s.data(), s.size()));
+    raw_mem_istream is(std::span<const char>(s.data(), s.size()));
     return parser(is).accept(true);
 }
 
-bool json::accept(span<const uint8_t> arr)
+bool json::accept(std::span<const uint8_t> arr)
 {
     raw_mem_istream is(arr);
     return parser(is).accept(true);
diff --git a/wpiutil/src/main/native/cpp/json_pointer.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json_pointer.cpp
similarity index 100%
rename from wpiutil/src/main/native/cpp/json_pointer.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json_pointer.cpp
diff --git a/wpiutil/src/main/native/cpp/json_serializer.cpp b/wpiutil/src/main/native/thirdparty/json/cpp/json_serializer.cpp
similarity index 100%
rename from wpiutil/src/main/native/cpp/json_serializer.cpp
rename to wpiutil/src/main/native/thirdparty/json/cpp/json_serializer.cpp
diff --git a/wpiutil/src/main/native/include/wpi/json.h b/wpiutil/src/main/native/thirdparty/json/include/wpi/json.h
similarity index 99%
rename from wpiutil/src/main/native/include/wpi/json.h
rename to wpiutil/src/main/native/thirdparty/json/include/wpi/json.h
index 1a4e410..1c07deb 100644
--- a/wpiutil/src/main/native/include/wpi/json.h
+++ b/wpiutil/src/main/native/thirdparty/json/include/wpi/json.h
@@ -43,7 +43,6 @@
 #include <algorithm> // all_of, copy, find, for_each, generate_n, min, reverse, remove, fill, none_of, transform
 #include <array> // array
 #include <cassert> // assert
-#include <ciso646> // and, not, or
 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
 #include <exception> // exception
@@ -52,6 +51,7 @@
 #include <iterator>
 #include <limits> // numeric_limits
 #include <memory> // allocator, shared_ptr, make_shared, addressof
+#include <span>
 #include <stdexcept> // runtime_error
 #include <string> // string, char_traits, stoi, to_string
 #include <string_view>
@@ -61,7 +61,6 @@
 #include <vector> // vector
 
 #include "wpi/StringMap.h"
-#include "wpi/span.h"
 
 namespace wpi
 {
@@ -1126,7 +1125,7 @@
     }
 
     template<typename BasicJsonType, typename T>
-    static void construct(BasicJsonType& j, span<T> arr)
+    static void construct(BasicJsonType& j, std::span<T> arr)
     {
         using std::begin;
         using std::end;
@@ -7015,7 +7014,7 @@
                             const parser_callback_t cb = nullptr,
                             const bool allow_exceptions = true);
 
-    static json parse(span<const uint8_t> arr,
+    static json parse(std::span<const uint8_t> arr,
                             const parser_callback_t cb = nullptr,
                             const bool allow_exceptions = true);
 
@@ -7028,7 +7027,7 @@
 
     static bool accept(std::string_view s);
 
-    static bool accept(span<const uint8_t> arr);
+    static bool accept(std::span<const uint8_t> arr);
 
     static bool accept(raw_istream& i);
 
@@ -7206,8 +7205,8 @@
     @since version 2.0.9
     */
     static std::vector<uint8_t> to_cbor(const json& j);
-    static span<uint8_t> to_cbor(const json& j, std::vector<uint8_t>& buf);
-    static span<uint8_t> to_cbor(const json& j, SmallVectorImpl<uint8_t>& buf);
+    static std::span<uint8_t> to_cbor(const json& j, std::vector<uint8_t>& buf);
+    static std::span<uint8_t> to_cbor(const json& j, SmallVectorImpl<uint8_t>& buf);
     static void to_cbor(raw_ostream& os, const json& j);
 
     /*!
@@ -7291,8 +7290,8 @@
     @since version 2.0.9
     */
     static std::vector<uint8_t> to_msgpack(const json& j);
-    static span<uint8_t> to_msgpack(const json& j, std::vector<uint8_t>& buf);
-    static span<uint8_t> to_msgpack(const json& j, SmallVectorImpl<uint8_t>& buf);
+    static std::span<uint8_t> to_msgpack(const json& j, std::vector<uint8_t>& buf);
+    static std::span<uint8_t> to_msgpack(const json& j, SmallVectorImpl<uint8_t>& buf);
     static void to_msgpack(raw_ostream& os, const json& j);
 
     /*!
@@ -7378,9 +7377,9 @@
     static std::vector<uint8_t> to_ubjson(const json& j,
                                           const bool use_size = false,
                                           const bool use_type = false);
-    static span<uint8_t> to_ubjson(const json& j, std::vector<uint8_t>& buf,
+    static std::span<uint8_t> to_ubjson(const json& j, std::vector<uint8_t>& buf,
                                    const bool use_size = false, const bool use_type = false);
-    static span<uint8_t> to_ubjson(const json& j, SmallVectorImpl<uint8_t>& buf,
+    static std::span<uint8_t> to_ubjson(const json& j, SmallVectorImpl<uint8_t>& buf,
                                    const bool use_size = false, const bool use_type = false);
     static void to_ubjson(raw_ostream& os, const json& j,
                           const bool use_size = false, const bool use_type = false);
@@ -7484,7 +7483,7 @@
     /*!
     @copydoc from_cbor(raw_istream&, const bool)
     */
-    static json from_cbor(span<const uint8_t> arr, const bool strict = true);
+    static json from_cbor(std::span<const uint8_t> arr, const bool strict = true);
 
     /*!
     @brief create a JSON value from an input in MessagePack format
@@ -7565,7 +7564,7 @@
     /*!
     @copydoc from_msgpack(raw_istream&, const bool)
     */
-    static json from_msgpack(span<const uint8_t> arr, const bool strict = true);
+    static json from_msgpack(std::span<const uint8_t> arr, const bool strict = true);
 
     /*!
     @brief create a JSON value from an input in UBJSON format
@@ -7623,7 +7622,7 @@
     static json from_ubjson(raw_istream& is,
                                   const bool strict = true);
 
-    static json from_ubjson(span<const uint8_t> arr, const bool strict = true);
+    static json from_ubjson(std::span<const uint8_t> arr, const bool strict = true);
 
     /// @}
 
diff --git a/wpiutil/src/main/native/include/wpi/json_serializer.h b/wpiutil/src/main/native/thirdparty/json/include/wpi/json_serializer.h
similarity index 100%
rename from wpiutil/src/main/native/include/wpi/json_serializer.h
rename to wpiutil/src/main/native/thirdparty/json/include/wpi/json_serializer.h
diff --git a/wpiutil/src/main/native/cpp/llvm/ConvertUTF.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTF.cpp
similarity index 98%
rename from wpiutil/src/main/native/cpp/llvm/ConvertUTF.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTF.cpp
index 3050e63..dbf41ab 100644
--- a/wpiutil/src/main/native/cpp/llvm/ConvertUTF.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTF.cpp
@@ -1,9 +1,8 @@
 /*===--- ConvertUTF.c - Universal Character Names conversions ---------------===
  *
- *                     The LLVM Compiler Infrastructure
- *
- * This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===------------------------------------------------------------------------=*/
 /*
@@ -755,7 +754,7 @@
     }
 
     utf16.reserve(len + 1);
-    utf16.set_size(len);
+    utf16.resize_for_overwrite(len);
 
     len = ::MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, original.data(),
                                 original.size(), utf16.begin(), utf16.size());
@@ -796,7 +795,7 @@
     }
 
     converted.reserve(len);
-    converted.set_size(len);
+    converted.resize_for_overwrite(len);
 
     // Now do the actual conversion.
     len = ::WideCharToMultiByte(codepage, 0, utf16, utf16_len, converted.data(),
@@ -829,6 +828,6 @@
 
 #endif  // _WIN32
 
-} // namespace llvm
+} // namespace wpi
 
 ConvertUTF_RESTORE_WARNINGS
diff --git a/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTFWrapper.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTFWrapper.cpp
new file mode 100644
index 0000000..e95c04f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ConvertUTFWrapper.cpp
@@ -0,0 +1,253 @@
+//===-- ConvertUTFWrapper.cpp - Wrap ConvertUTF.h with clang data types -----===
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <span>
+#include "wpi/ConvertUTF.h"
+#include "wpi/SmallVector.h"
+#include "wpi/ErrorHandling.h"
+#include "wpi/SwapByteOrder.h"
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace wpi {
+
+bool ConvertUTF8toWide(unsigned WideCharWidth, std::string_view Source,
+                       char *&ResultPtr, const UTF8 *&ErrorPtr) {
+  assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
+  ConversionResult result = conversionOK;
+  // Copy the character std::span over.
+  if (WideCharWidth == 1) {
+    const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.data());
+    if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.data() + Source.size()))) {
+      result = sourceIllegal;
+      ErrorPtr = Pos;
+    } else {
+      memcpy(ResultPtr, Source.data(), Source.size());
+      ResultPtr += Source.size();
+    }
+  } else if (WideCharWidth == 2) {
+    const UTF8 *sourceStart = (const UTF8*)Source.data();
+    // FIXME: Make the type of the result buffer correct instead of
+    // using reinterpret_cast.
+    UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr);
+    ConversionFlags flags = strictConversion;
+    result = ConvertUTF8toUTF16(
+        &sourceStart, sourceStart + Source.size(),
+        &targetStart, targetStart + Source.size(), flags);
+    if (result == conversionOK)
+      ResultPtr = reinterpret_cast<char*>(targetStart);
+    else
+      ErrorPtr = sourceStart;
+  } else if (WideCharWidth == 4) {
+    const UTF8 *sourceStart = (const UTF8*)Source.data();
+    // FIXME: Make the type of the result buffer correct instead of
+    // using reinterpret_cast.
+    UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr);
+    ConversionFlags flags = strictConversion;
+    result = ConvertUTF8toUTF32(
+        &sourceStart, sourceStart + Source.size(),
+        &targetStart, targetStart + Source.size(), flags);
+    if (result == conversionOK)
+      ResultPtr = reinterpret_cast<char*>(targetStart);
+    else
+      ErrorPtr = sourceStart;
+  }
+  assert((result != targetExhausted)
+         && "ConvertUTF8toUTFXX exhausted target buffer");
+  return result == conversionOK;
+}
+
+bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr) {
+  const UTF32 *SourceStart = &Source;
+  const UTF32 *SourceEnd = SourceStart + 1;
+  UTF8 *TargetStart = reinterpret_cast<UTF8 *>(ResultPtr);
+  UTF8 *TargetEnd = TargetStart + 4;
+  ConversionResult CR = ConvertUTF32toUTF8(&SourceStart, SourceEnd,
+                                           &TargetStart, TargetEnd,
+                                           strictConversion);
+  if (CR != conversionOK)
+    return false;
+
+  ResultPtr = reinterpret_cast<char*>(TargetStart);
+  return true;
+}
+
+bool hasUTF16ByteOrderMark(std::span<const char> S) {
+  return (S.size() >= 2 &&
+          ((S[0] == '\xff' && S[1] == '\xfe') ||
+           (S[0] == '\xfe' && S[1] == '\xff')));
+}
+
+bool convertUTF16ToUTF8String(std::span<const char> SrcBytes, SmallVectorImpl<char> &Out) {
+  assert(Out.empty());
+
+  // Error out on an uneven byte count.
+  if (SrcBytes.size() % 2)
+    return false;
+
+  // Avoid OOB by returning early on empty input.
+  if (SrcBytes.empty())
+    return true;
+
+  const UTF16 *Src = reinterpret_cast<const UTF16 *>(&*SrcBytes.begin());
+  const UTF16 *SrcEnd = reinterpret_cast<const UTF16 *>(&*SrcBytes.begin() + SrcBytes.size());
+
+  assert((uintptr_t)Src % sizeof(UTF16) == 0);
+
+  // Byteswap if necessary.
+  std::vector<UTF16> ByteSwapped;
+  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_SWAPPED) {
+    ByteSwapped.insert(ByteSwapped.end(), Src, SrcEnd);
+    for (UTF16 &I : ByteSwapped)
+      I = wpi::ByteSwap_16(I);
+    Src = &ByteSwapped[0];
+    SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;
+  }
+
+  // Skip the BOM for conversion.
+  if (Src[0] == UNI_UTF16_BYTE_ORDER_MARK_NATIVE)
+    Src++;
+
+  // Just allocate enough space up front.  We'll shrink it later.  Allocate
+  // enough that we can fit a null terminator without reallocating.
+  Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
+  UTF8 *Dst = reinterpret_cast<UTF8 *>(&Out[0]);
+  UTF8 *DstEnd = Dst + Out.size();
+
+  ConversionResult CR =
+      ConvertUTF16toUTF8(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
+  assert(CR != targetExhausted);
+
+  if (CR != conversionOK) {
+    Out.clear();
+    return false;
+  }
+
+  Out.resize(reinterpret_cast<char *>(Dst) - &Out[0]);
+  Out.push_back(0);
+  Out.pop_back();
+  return true;
+}
+
+bool convertUTF16ToUTF8String(std::span<const UTF16> Src, SmallVectorImpl<char> &Out)
+{
+  return convertUTF16ToUTF8String(
+      std::span<const char>(reinterpret_cast<const char *>(Src.data()),
+      Src.size() * sizeof(UTF16)), Out);
+}
+
+bool convertUTF8ToUTF16String(std::string_view SrcUTF8,
+                              SmallVectorImpl<UTF16> &DstUTF16) {
+  assert(DstUTF16.empty());
+
+  // Avoid OOB by returning early on empty input.
+  if (SrcUTF8.empty()) {
+    DstUTF16.push_back(0);
+    DstUTF16.pop_back();
+    return true;
+  }
+
+  const UTF8 *Src = reinterpret_cast<const UTF8 *>(SrcUTF8.data());
+  const UTF8 *SrcEnd = reinterpret_cast<const UTF8 *>(SrcUTF8.data() + SrcUTF8.size());
+
+  // Allocate the same number of UTF-16 code units as UTF-8 code units. Encoding
+  // as UTF-16 should always require the same amount or less code units than the
+  // UTF-8 encoding.  Allocate one extra byte for the null terminator though,
+  // so that someone calling DstUTF16.data() gets a null terminated string.
+  // We resize down later so we don't have to worry that this over allocates.
+  DstUTF16.resize(SrcUTF8.size()+1);
+  UTF16 *Dst = &DstUTF16[0];
+  UTF16 *DstEnd = Dst + DstUTF16.size();
+
+  ConversionResult CR =
+      ConvertUTF8toUTF16(&Src, SrcEnd, &Dst, DstEnd, strictConversion);
+  assert(CR != targetExhausted);
+
+  if (CR != conversionOK) {
+    DstUTF16.clear();
+    return false;
+  }
+
+  DstUTF16.resize(Dst - &DstUTF16[0]);
+  DstUTF16.push_back(0);
+  DstUTF16.pop_back();
+  return true;
+}
+
+static_assert(sizeof(wchar_t) == 1 || sizeof(wchar_t) == 2 ||
+                  sizeof(wchar_t) == 4,
+              "Expected wchar_t to be 1, 2, or 4 bytes");
+
+template <typename TResult>
+static inline bool ConvertUTF8toWideInternal(std::string_view Source,
+                                             TResult &Result) {
+  // Even in the case of UTF-16, the number of bytes in a UTF-8 string is
+  // at least as large as the number of elements in the resulting wide
+  // string, because surrogate pairs take at least 4 bytes in UTF-8.
+  Result.resize(Source.size() + 1);
+  char *ResultPtr = reinterpret_cast<char *>(&Result[0]);
+  const UTF8 *ErrorPtr;
+  if (!ConvertUTF8toWide(sizeof(wchar_t), Source, ResultPtr, ErrorPtr)) {
+    Result.clear();
+    return false;
+  }
+  Result.resize(reinterpret_cast<wchar_t *>(ResultPtr) - &Result[0]);
+  return true;
+}
+
+bool ConvertUTF8toWide(std::string_view Source, std::wstring &Result) {
+  return ConvertUTF8toWideInternal(Source, Result);
+}
+
+bool ConvertUTF8toWide(const char *Source, std::wstring &Result) {
+  if (!Source) {
+    Result.clear();
+    return true;
+  }
+  return ConvertUTF8toWide(std::string_view(Source), Result);
+}
+
+bool convertWideToUTF8(const std::wstring &Source, SmallVectorImpl<char> &Result) {
+  if (sizeof(wchar_t) == 1) {
+    const UTF8 *Start = reinterpret_cast<const UTF8 *>(Source.data());
+    const UTF8 *End =
+        reinterpret_cast<const UTF8 *>(Source.data() + Source.size());
+    if (!isLegalUTF8String(&Start, End))
+      return false;
+    Result.resize(Source.size());
+    memcpy(&Result[0], Source.data(), Source.size());
+    return true;
+  } else if (sizeof(wchar_t) == 2) {
+    return convertUTF16ToUTF8String(
+        std::span<const UTF16>(reinterpret_cast<const UTF16 *>(Source.data()),
+                              Source.size()),
+        Result);
+  } else if (sizeof(wchar_t) == 4) {
+    const UTF32 *Start = reinterpret_cast<const UTF32 *>(Source.data());
+    const UTF32 *End =
+        reinterpret_cast<const UTF32 *>(Source.data() + Source.size());
+    Result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * Source.size());
+    UTF8 *ResultPtr = reinterpret_cast<UTF8 *>(&Result[0]);
+    UTF8 *ResultEnd = reinterpret_cast<UTF8 *>(&Result[0] + Result.size());
+    if (ConvertUTF32toUTF8(&Start, End, &ResultPtr, ResultEnd,
+                           strictConversion) == conversionOK) {
+      Result.resize(reinterpret_cast<char *>(ResultPtr) - &Result[0]);
+      return true;
+    } else {
+      Result.clear();
+      return false;
+    }
+  } else {
+    wpi_unreachable(
+        "Control should never reach this point; see static_assert further up");
+  }
+}
+
+} // end namespace wpi
+
diff --git a/wpiutil/src/main/native/cpp/llvm/ErrorHandling.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ErrorHandling.cpp
similarity index 85%
rename from wpiutil/src/main/native/cpp/llvm/ErrorHandling.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ErrorHandling.cpp
index 22ae636..ea89b38 100644
--- a/wpiutil/src/main/native/cpp/llvm/ErrorHandling.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/ErrorHandling.cpp
@@ -1,9 +1,8 @@
 //===- lib/Support/ErrorHandling.cpp - Callbacks for errors ---------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,10 +13,10 @@
 
 #include "wpi/ErrorHandling.h"
 #include "wpi/SmallVector.h"
+#include "wpi/Errc.h"
 #include "wpi/WindowsError.h"
 #include "fmt/format.h"
 #include <cassert>
-#include <cstdio>
 #include <cstdlib>
 #include <mutex>
 #include <new>
@@ -25,7 +24,6 @@
 #ifndef _WIN32
 #include <unistd.h>
 #endif
-
 #if defined(_MSC_VER)
 #include <io.h>
 #endif
@@ -53,7 +51,7 @@
 static std::mutex BadAllocErrorHandlerMutex;
 
 void wpi::install_fatal_error_handler(fatal_error_handler_t handler,
-                                      void *user_data) {
+                                       void *user_data) {
   std::scoped_lock Lock(ErrorHandlerMutex);
   assert(!ErrorHandler && "Error handler already registered!\n");
   ErrorHandler = handler;
@@ -86,7 +84,7 @@
   }
 
   if (handler) {
-    handler(handlerData, std::string{Reason}, GenCrashDiag);
+    handler(handlerData, std::string{Reason}.c_str(), GenCrashDiag);
   } else {
     fmt::print(stderr, "LLVM ERROR: {}\n", Reason);
   }
@@ -95,7 +93,7 @@
 }
 
 void wpi::install_bad_alloc_error_handler(fatal_error_handler_t handler,
-                                          void *user_data) {
+                                           void *user_data) {
   std::scoped_lock Lock(BadAllocErrorHandlerMutex);
   assert(!ErrorHandler && "Bad alloc error handler already registered!\n");
   BadAllocErrorHandler = handler;
@@ -126,13 +124,17 @@
 
   // Don't call the normal error handler. It may allocate memory. Directly write
   // an OOM to stderr and abort.
-  char OOMMessage[] = "LLVM ERROR: out of memory\n";
+  const char *OOMMessage = "LLVM ERROR: out of memory\n";
+  const char *Newline = "\n";
 #ifdef _WIN32
-  int written = ::_write(2, OOMMessage, strlen(OOMMessage));
+  (void)!::_write(2, OOMMessage, strlen(OOMMessage));
+  (void)!::_write(2, Reason, strlen(Reason));
+  (void)!::_write(2, Newline, strlen(Newline));
 #else
-  ssize_t written = ::write(2, OOMMessage, strlen(OOMMessage));
+  (void)!::write(2, OOMMessage, strlen(OOMMessage));
+  (void)!::write(2, Reason, strlen(Reason));
+  (void)!::write(2, Newline, strlen(Newline));
 #endif
-  (void)written;
   abort();
 }
 
@@ -142,28 +144,17 @@
   wpi::report_bad_alloc_error("Allocation failed");
 }
 
-// Installs new handler that causes crash on allocation failure. It does not
-// need to be called explicitly, if this file is linked to application, because
-// in this case it is called during construction of 'new_handler_installer'.
+// Installs new handler that causes crash on allocation failure. It is called by
+// InitLLVM.
 void wpi::install_out_of_memory_new_handler() {
-  static bool out_of_memory_new_handler_installed = false;
-  if (!out_of_memory_new_handler_installed) {
-    std::set_new_handler(out_of_memory_new_handler);
-    out_of_memory_new_handler_installed = true;
-  }
+  std::new_handler old = std::set_new_handler(out_of_memory_new_handler);
+  (void)old;
+  assert((old == nullptr || old == out_of_memory_new_handler) &&
+         "new-handler already installed");
 }
 
-// Static object that causes installation of 'out_of_memory_new_handler' before
-// execution of 'main'.
-static class NewHandlerInstaller {
-public:
-  NewHandlerInstaller() {
-    install_out_of_memory_new_handler();
-  }
-} new_handler_installer;
-
 void wpi::wpi_unreachable_internal(const char *msg, const char *file,
-                                   unsigned line) {
+                                     unsigned line) {
   // This code intentionally doesn't call the ErrorHandler callback, because
   // wpi_unreachable is intended to be used to indicate "impossible"
   // situations, and not legitimate runtime errors.
@@ -172,7 +163,7 @@
   std::fputs("UNREACHABLE executed", stderr);
   if (file)
     fmt::print(stderr, " at {}:{}", file, line);
-  fmt::print(stderr, "{}", "!\n");
+  fmt::print(stderr, "!\n");
   abort();
 #ifdef LLVM_BUILTIN_UNREACHABLE
   // Windows systems and possibly others don't declare abort() to be noreturn,
@@ -183,7 +174,6 @@
 
 #ifdef _WIN32
 
-#include <system_error>
 #include <winerror.h>
 
 // I'd rather not double the line count of the following.
@@ -195,7 +185,10 @@
   switch (EV) {
     MAP_ERR_TO_COND(ERROR_ACCESS_DENIED, permission_denied);
     MAP_ERR_TO_COND(ERROR_ALREADY_EXISTS, file_exists);
+    MAP_ERR_TO_COND(ERROR_BAD_NETPATH, no_such_file_or_directory);
+    MAP_ERR_TO_COND(ERROR_BAD_PATHNAME, no_such_file_or_directory);
     MAP_ERR_TO_COND(ERROR_BAD_UNIT, no_such_device);
+    MAP_ERR_TO_COND(ERROR_BROKEN_PIPE, broken_pipe);
     MAP_ERR_TO_COND(ERROR_BUFFER_OVERFLOW, filename_too_long);
     MAP_ERR_TO_COND(ERROR_BUSY, device_or_resource_busy);
     MAP_ERR_TO_COND(ERROR_BUSY_DRIVE, device_or_resource_busy);
@@ -217,18 +210,20 @@
     MAP_ERR_TO_COND(ERROR_INVALID_FUNCTION, function_not_supported);
     MAP_ERR_TO_COND(ERROR_INVALID_HANDLE, invalid_argument);
     MAP_ERR_TO_COND(ERROR_INVALID_NAME, invalid_argument);
+    MAP_ERR_TO_COND(ERROR_INVALID_PARAMETER, invalid_argument);
     MAP_ERR_TO_COND(ERROR_LOCK_VIOLATION, no_lock_available);
     MAP_ERR_TO_COND(ERROR_LOCKED, no_lock_available);
     MAP_ERR_TO_COND(ERROR_NEGATIVE_SEEK, invalid_argument);
     MAP_ERR_TO_COND(ERROR_NOACCESS, permission_denied);
     MAP_ERR_TO_COND(ERROR_NOT_ENOUGH_MEMORY, not_enough_memory);
     MAP_ERR_TO_COND(ERROR_NOT_READY, resource_unavailable_try_again);
+    MAP_ERR_TO_COND(ERROR_NOT_SUPPORTED, not_supported);
     MAP_ERR_TO_COND(ERROR_OPEN_FAILED, io_error);
     MAP_ERR_TO_COND(ERROR_OPEN_FILES, device_or_resource_busy);
     MAP_ERR_TO_COND(ERROR_OUTOFMEMORY, not_enough_memory);
     MAP_ERR_TO_COND(ERROR_PATH_NOT_FOUND, no_such_file_or_directory);
-    MAP_ERR_TO_COND(ERROR_BAD_NETPATH, no_such_file_or_directory);
     MAP_ERR_TO_COND(ERROR_READ_FAULT, io_error);
+    MAP_ERR_TO_COND(ERROR_REPARSE_TAG_INVALID, invalid_argument);
     MAP_ERR_TO_COND(ERROR_RETRY, resource_unavailable_try_again);
     MAP_ERR_TO_COND(ERROR_SEEK, io_error);
     MAP_ERR_TO_COND(ERROR_SHARING_VIOLATION, permission_denied);
diff --git a/wpiutil/src/main/native/cpp/llvm/Hashing.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Hashing.cpp
similarity index 82%
rename from wpiutil/src/main/native/cpp/llvm/Hashing.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Hashing.cpp
index e916751..a719d3f 100644
--- a/wpiutil/src/main/native/cpp/llvm/Hashing.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Hashing.cpp
@@ -1,9 +1,8 @@
 //===-------------- lib/Support/Hashing.cpp -------------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemAlloc.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemAlloc.cpp
new file mode 100644
index 0000000..e2c662c
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemAlloc.cpp
@@ -0,0 +1,35 @@
+//===- MemAlloc.cpp - Memory allocation functions -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/MemAlloc.h"
+#include <new>
+
+// These are out of line to have __cpp_aligned_new not affect ABI.
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+wpi::allocate_buffer(size_t Size, size_t Alignment) {
+  return ::operator new(Size
+#ifdef __cpp_aligned_new
+                        ,
+                        std::align_val_t(Alignment)
+#endif
+  );
+}
+
+void wpi::deallocate_buffer(void *Ptr, size_t Size, size_t Alignment) {
+  ::operator delete(Ptr
+#ifdef __cpp_sized_deallocation
+                    ,
+                    Size
+#endif
+#ifdef __cpp_aligned_new
+                    ,
+                    std::align_val_t(Alignment)
+#endif
+  );
+}
diff --git a/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemoryBuffer.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemoryBuffer.cpp
new file mode 100644
index 0000000..5beeb38
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/MemoryBuffer.cpp
@@ -0,0 +1,522 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+//===--- MemoryBuffer.cpp - Memory Buffer implementation ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the MemoryBuffer interface.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/MemoryBuffer.h"
+
+#ifdef _MSC_VER
+// no matching operator delete
+#pragma warning(disable : 4291)
+#endif
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>  // NOLINT(build/include_order)
+
+#endif
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _MSC_VER
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#include <cassert>
+#include <cerrno>
+#include <cstring>
+#include <new>
+#include <system_error>
+
+#include "wpi/Errc.h"
+#include "wpi/Errno.h"
+#include "wpi/MappedFileRegion.h"
+#include "wpi/MathExtras.h"
+#include "wpi/SmallVector.h"
+#include "wpi/SmallVectorMemoryBuffer.h"
+#include "wpi/fs.h"
+
+#ifdef _WIN32
+#include "wpi/WindowsError.h"
+#endif
+
+using namespace wpi;
+
+//===----------------------------------------------------------------------===//
+// MemoryBuffer implementation itself.
+//===----------------------------------------------------------------------===//
+
+MemoryBuffer::~MemoryBuffer() {}
+
+/// init - Initialize this MemoryBuffer as a reference to externally allocated
+/// memory.
+void MemoryBuffer::Init(const uint8_t* bufStart, const uint8_t* bufEnd) {
+  m_bufferStart = bufStart;
+  m_bufferEnd = bufEnd;
+}
+
+//===----------------------------------------------------------------------===//
+// MemoryBufferMem implementation.
+//===----------------------------------------------------------------------===//
+
+/// CopyStringRef - Copies contents of a StringRef into a block of memory and
+/// null-terminates it.
+static void CopyStringView(uint8_t* memory, std::string_view data) {
+  if (!data.empty()) {
+    std::memcpy(memory, data.data(), data.size());
+  }
+  memory[data.size()] = 0;  // Null terminate string.
+}
+
+namespace {
+struct NamedBufferAlloc {
+  std::string_view name;
+  explicit NamedBufferAlloc(std::string_view name) : name(name) {}
+};
+}  // namespace
+
+void* operator new(size_t N, NamedBufferAlloc alloc) {
+  uint8_t* mem = static_cast<uint8_t*>(operator new(N + alloc.name.size() + 1));
+  CopyStringView(mem + N, alloc.name);
+  return mem;
+}
+
+namespace {
+/// MemoryBufferMem - Named MemoryBuffer pointing to a block of memory.
+template <typename MB>
+class MemoryBufferMem : public MB {
+ public:
+  explicit MemoryBufferMem(std::span<const uint8_t> inputData) {
+    MemoryBuffer::Init(inputData.data(), inputData.data() + inputData.size());
+  }
+
+  /// Disable sized deallocation for MemoryBufferMem, because it has
+  /// tail-allocated data.
+  void operator delete(void* p) { ::operator delete(p); }  // NOLINT
+
+  std::string_view GetBufferIdentifier() const override {
+    // The name is stored after the class itself.
+    return std::string_view(reinterpret_cast<const char*>(this + 1));
+  }
+
+  MemoryBuffer::BufferKind GetBufferKind() const override {
+    return MemoryBuffer::MemoryBuffer_Malloc;
+  }
+};
+}  // namespace
+
+template <typename MB>
+static std::unique_ptr<MB> GetFileAux(std::string_view filename,
+                                      std::error_code& ec, int64_t fileSize,
+                                      uint64_t mapSize, uint64_t offset);
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetMemBuffer(
+    std::span<const uint8_t> inputData, std::string_view bufferName) {
+  auto* ret = new (NamedBufferAlloc(bufferName))
+      MemoryBufferMem<MemoryBuffer>(inputData);
+  return std::unique_ptr<MemoryBuffer>(ret);
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetMemBuffer(MemoryBufferRef ref) {
+  return std::unique_ptr<MemoryBuffer>(
+      GetMemBuffer(ref.GetBuffer(), ref.GetBufferIdentifier()));
+}
+
+static std::unique_ptr<WritableMemoryBuffer> GetMemBufferCopyImpl(
+    std::span<const uint8_t> inputData, std::string_view bufferName,
+    std::error_code& ec) {
+  auto buf =
+      WritableMemoryBuffer::GetNewUninitMemBuffer(inputData.size(), bufferName);
+  if (!buf) {
+    ec = make_error_code(errc::not_enough_memory);
+    return nullptr;
+  }
+  std::memcpy(buf->begin(), inputData.data(), inputData.size());
+  return buf;
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetMemBufferCopy(
+    std::span<const uint8_t> inputData, std::string_view bufferName) {
+  std::error_code ec;
+  return GetMemBufferCopyImpl(inputData, bufferName, ec);
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetFileSlice(
+    std::string_view filePath, std::error_code& ec, uint64_t mapSize,
+    uint64_t offset) {
+  return GetFileAux<MemoryBuffer>(filePath, ec, -1, mapSize, offset);
+}
+
+//===----------------------------------------------------------------------===//
+// MemoryBuffer::getFile implementation.
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+template <typename MB>
+constexpr auto kMapMode = MappedFileRegion::kReadOnly;
+template <>
+constexpr auto kMapMode<MemoryBuffer> = MappedFileRegion::kReadOnly;
+template <>
+constexpr auto kMapMode<WritableMemoryBuffer> = MappedFileRegion::kPriv;
+template <>
+constexpr auto kMapMode<WriteThroughMemoryBuffer> =
+    MappedFileRegion::kReadWrite;
+
+/// Memory maps a file descriptor using MappedFileRegion.
+///
+/// This handles converting the offset into a legal offset on the platform.
+template <typename MB>
+class MemoryBufferMMapFile : public MB {
+  MappedFileRegion m_mfr;
+
+  static uint64_t getLegalMapOffset(uint64_t offset) {
+    return offset & ~(MappedFileRegion::GetAlignment() - 1);
+  }
+
+  static uint64_t getLegalMapSize(uint64_t len, uint64_t offset) {
+    return len + (offset - getLegalMapOffset(offset));
+  }
+
+  const uint8_t* getStart(uint64_t len, uint64_t offset) {
+    return m_mfr.const_data() + (offset - getLegalMapOffset(offset));
+  }
+
+ public:
+  MemoryBufferMMapFile(fs::file_t f, uint64_t len, uint64_t offset,
+                       std::error_code& ec)
+      : m_mfr(f, getLegalMapSize(len, offset), getLegalMapOffset(offset),
+              kMapMode<MB>, ec) {
+    if (!ec) {
+      const uint8_t* Start = getStart(len, offset);
+      MemoryBuffer::Init(Start, Start + len);
+    }
+  }
+
+  /// Disable sized deallocation for MemoryBufferMMapFile, because it has
+  /// tail-allocated data.
+  void operator delete(void* p) { ::operator delete(p); }  // NOLINT
+
+  std::string_view GetBufferIdentifier() const override {
+    // The name is stored after the class itself.
+    return std::string_view(reinterpret_cast<const char*>(this + 1));
+  }
+
+  MemoryBuffer::BufferKind GetBufferKind() const override {
+    return MemoryBuffer::MemoryBuffer_MMap;
+  }
+};
+}  // namespace
+
+static std::unique_ptr<WritableMemoryBuffer> GetMemoryBufferForStream(
+    fs::file_t f, std::string_view bufferName, std::error_code& ec) {
+  constexpr size_t ChunkSize = 4096 * 4;
+  SmallVector<uint8_t, ChunkSize> buffer;
+#ifdef _WIN32
+  DWORD readBytes;
+#else
+  ssize_t readBytes;
+#endif
+  // Read into Buffer until we hit EOF.
+  do {
+    buffer.resize_for_overwrite(buffer.size() + ChunkSize);
+#ifdef _WIN32
+    if (!ReadFile(f, buffer.end(), ChunkSize, &readBytes, nullptr)) {
+      ec = mapWindowsError(GetLastError());
+      return nullptr;
+    }
+#else
+    readBytes = sys::RetryAfterSignal(-1, ::read, f, buffer.end(), ChunkSize);
+    if (readBytes == -1) {
+      ec = std::error_code(errno, std::generic_category());
+      return nullptr;
+    }
+#endif
+  } while (readBytes != 0);
+
+  return GetMemBufferCopyImpl(buffer, bufferName, ec);
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetFile(std::string_view filename,
+                                                    std::error_code& ec,
+                                                    int64_t fileSize) {
+  return GetFileAux<MemoryBuffer>(filename, ec, fileSize, fileSize, 0);
+}
+
+template <typename MB>
+static std::unique_ptr<MB> GetOpenFileImpl(fs::file_t f,
+                                           std::string_view filename,
+                                           std::error_code& ec,
+                                           uint64_t fileSize, uint64_t mapSize,
+                                           int64_t offset);
+
+template <typename MB>
+static std::unique_ptr<MB> GetFileAux(std::string_view filename,
+                                      std::error_code& ec, int64_t fileSize,
+                                      uint64_t mapSize, uint64_t offset) {
+  fs::file_t F = fs::OpenFileForRead(filename, ec, fs::OF_None);
+  if (ec) {
+    return nullptr;
+  }
+
+  auto Ret = GetOpenFileImpl<MB>(F, filename, ec, fileSize, mapSize, offset);
+  fs::CloseFile(F);
+  return Ret;
+}
+
+std::unique_ptr<WritableMemoryBuffer> WritableMemoryBuffer::GetFile(
+    std::string_view filename, std::error_code& ec, int64_t fileSize) {
+  return GetFileAux<WritableMemoryBuffer>(filename, ec, fileSize, fileSize, 0);
+}
+
+std::unique_ptr<WritableMemoryBuffer> WritableMemoryBuffer::GetFileSlice(
+    std::string_view filename, std::error_code& ec, uint64_t mapSize,
+    uint64_t offset) {
+  return GetFileAux<WritableMemoryBuffer>(filename, ec, -1, mapSize, offset);
+}
+
+std::unique_ptr<WritableMemoryBuffer>
+WritableMemoryBuffer::GetNewUninitMemBuffer(size_t size,
+                                            std::string_view bufferName) {
+  using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>;
+  // Allocate space for the MemoryBuffer, the data and the name. It is important
+  // that MemoryBuffer and data are aligned so PointerIntPair works with them.
+  // TODO: Is 16-byte alignment enough?  We copy small object files with large
+  // alignment expectations into this buffer.
+  size_t alignedStringLen =
+      alignTo(sizeof(MemBuffer) + bufferName.size() + 1, 16);
+  size_t realLen = alignedStringLen + size + 1;
+  uint8_t* mem = static_cast<uint8_t*>(operator new(realLen, std::nothrow));
+  if (!mem) {
+    return nullptr;
+  }
+
+  // The name is stored after the class itself.
+  CopyStringView(mem + sizeof(MemBuffer), bufferName);
+
+  // The buffer begins after the name and must be aligned.
+  uint8_t* buf = mem + alignedStringLen;
+  buf[size] = 0;  // Null terminate buffer.
+
+  auto* ret = new (mem) MemBuffer({buf, size});
+  return std::unique_ptr<WritableMemoryBuffer>(ret);
+}
+
+std::unique_ptr<WritableMemoryBuffer> WritableMemoryBuffer::GetNewMemBuffer(
+    size_t size, std::string_view bufferName) {
+  auto sb = WritableMemoryBuffer::GetNewUninitMemBuffer(size, bufferName);
+  if (!sb) {
+    return nullptr;
+  }
+  std::memset(sb->begin(), 0, size);
+  return sb;
+}
+
+static std::unique_ptr<WriteThroughMemoryBuffer> GetReadWriteFile(
+    std::string_view filename, std::error_code& ec, uint64_t fileSize,
+    uint64_t mapSize, uint64_t offset) {
+  fs::file_t f =
+      fs::OpenFileForReadWrite(filename, ec, fs::CD_OpenExisting, fs::OF_None);
+  if (ec) {
+    return nullptr;
+  }
+
+  // Default is to map the full file.
+  if (mapSize == uint64_t(-1)) {
+    // If we don't know the file size, use fstat to find out.  fstat on an open
+    // file descriptor is cheaper than stat on a random path.
+    if (fileSize == uint64_t(-1)) {
+#ifdef _WIN32
+      // If this not a file or a block device (e.g. it's a named pipe
+      // or character device), we can't mmap it, so error out.
+      if (GetFileType(f) != FILE_TYPE_DISK) {
+        ec = std::error_code(errno, std::generic_category());
+        return nullptr;
+      }
+
+      LARGE_INTEGER fileSizeWin;
+      if (!GetFileSizeEx(f, &fileSizeWin)) {
+        ec = wpi::mapWindowsError(GetLastError());
+        return nullptr;
+      }
+      fileSize = fileSizeWin.QuadPart;
+#else
+      struct stat status;
+      if (fstat(f, &status) < 0) {
+        ec = std::error_code(errno, std::generic_category());
+        return nullptr;
+      }
+
+      // If this not a file or a block device (e.g. it's a named pipe
+      // or character device), we can't mmap it, so error out.
+      if (status.st_mode != S_IFREG && status.st_mode != S_IFBLK) {
+        ec = make_error_code(errc::invalid_argument);
+        return nullptr;
+      }
+
+      fileSize = status.st_size;
+#endif
+    }
+    mapSize = fileSize;
+  }
+
+  std::unique_ptr<WriteThroughMemoryBuffer> result(new (NamedBufferAlloc(
+      filename)) MemoryBufferMMapFile<WriteThroughMemoryBuffer>(f, mapSize,
+                                                                offset, ec));
+  if (ec) {
+    return nullptr;
+  }
+  return result;
+}
+
+std::unique_ptr<WriteThroughMemoryBuffer> WriteThroughMemoryBuffer::GetFile(
+    std::string_view filename, std::error_code& ec, int64_t fileSize) {
+  return GetReadWriteFile(filename, ec, fileSize, fileSize, 0);
+}
+
+/// Map a subrange of the specified file as a WritableMemoryBuffer.
+std::unique_ptr<WriteThroughMemoryBuffer>
+WriteThroughMemoryBuffer::GetFileSlice(std::string_view filename,
+                                       std::error_code& ec, uint64_t mapSize,
+                                       uint64_t offset) {
+  return GetReadWriteFile(filename, ec, -1, mapSize, offset);
+}
+
+template <typename MB>
+static std::unique_ptr<MB> GetOpenFileImpl(fs::file_t f,
+                                           std::string_view filename,
+                                           std::error_code& ec,
+                                           uint64_t fileSize, uint64_t mapSize,
+                                           int64_t offset) {
+  // Default is to map the full file.
+  if (mapSize == uint64_t(-1)) {
+    // If we don't know the file size, use fstat to find out.  fstat on an open
+    // file descriptor is cheaper than stat on a random path.
+    if (fileSize == uint64_t(-1)) {
+#ifdef _WIN32
+      // If this not a file or a block device (e.g. it's a named pipe
+      // or character device), we can't trust the size. Create the memory
+      // buffer by copying off the stream.
+      LARGE_INTEGER fileSizeWin;
+      if (GetFileType(f) != FILE_TYPE_DISK || !GetFileSizeEx(f, &fileSizeWin)) {
+        return GetMemoryBufferForStream(f, filename, ec);
+      }
+      fileSize = fileSizeWin.QuadPart;
+#else
+      struct stat status;
+      if (fstat(f, &status) < 0) {
+        ec = std::error_code(errno, std::generic_category());
+        return nullptr;
+      }
+
+      // If this not a file or a block device (e.g. it's a named pipe
+      // or character device), we can't trust the size. Create the memory
+      // buffer by copying off the stream.
+      if (status.st_mode != S_IFREG && status.st_mode != S_IFBLK) {
+        return GetMemoryBufferForStream(f, filename, ec);
+      }
+
+      fileSize = status.st_size;
+#endif
+    }
+    mapSize = fileSize;
+  }
+
+  // Don't use mmap for small files
+  if (mapSize >= 4 * 4096) {
+    std::unique_ptr<MB> result(new (NamedBufferAlloc(
+        filename)) MemoryBufferMMapFile<MB>(f, mapSize, offset, ec));
+    if (!ec) {
+      return result;
+    }
+  }
+
+  auto buf = WritableMemoryBuffer::GetNewUninitMemBuffer(mapSize, filename);
+  if (!buf) {
+    // Failed to create a buffer. The only way it can fail is if
+    // new(std::nothrow) returns 0.
+    ec = make_error_code(errc::not_enough_memory);
+    return nullptr;
+  }
+
+  uint8_t* bufPtr = buf.get()->begin();
+
+  size_t bytesLeft = mapSize;
+  while (bytesLeft) {
+#ifdef _WIN32
+    LARGE_INTEGER offsetWin;
+    offsetWin.QuadPart = offset;
+    DWORD numRead;
+    if (!SetFilePointerEx(f, offsetWin, nullptr, FILE_BEGIN) ||
+        !ReadFile(f, bufPtr, bytesLeft, &numRead, nullptr)) {
+      ec = mapWindowsError(GetLastError());
+      return nullptr;
+    }
+// TODO
+#else
+    ssize_t numRead = sys::RetryAfterSignal(-1, ::pread, f, bufPtr, bytesLeft,
+                                            mapSize - bytesLeft + offset);
+    if (numRead == -1) {
+      // Error while reading.
+      ec = std::error_code(errno, std::generic_category());
+      return nullptr;
+    }
+#endif
+    if (numRead == 0) {
+      std::memset(bufPtr, 0, bytesLeft);  // zero-initialize rest of the buffer.
+      break;
+    }
+    bytesLeft -= numRead;
+    bufPtr += numRead;
+  }
+
+  return buf;
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetOpenFile(
+    fs::file_t f, std::string_view filename, std::error_code& ec,
+    uint64_t fileSize) {
+  return GetOpenFileImpl<MemoryBuffer>(f, filename, ec, fileSize, fileSize, 0);
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetOpenFileSlice(
+    fs::file_t f, std::string_view filename, std::error_code& ec,
+    uint64_t mapSize, int64_t offset) {
+  assert(mapSize != uint64_t(-1));
+  return GetOpenFileImpl<MemoryBuffer>(f, filename, ec, -1, mapSize, offset);
+}
+
+std::unique_ptr<MemoryBuffer> MemoryBuffer::GetFileAsStream(
+    std::string_view filename, std::error_code& ec) {
+  fs::file_t f = fs::OpenFileForRead(filename, ec, fs::OF_None);
+  if (ec) {
+    return nullptr;
+  }
+  std::unique_ptr<MemoryBuffer> ret = GetMemoryBufferForStream(f, filename, ec);
+  fs::CloseFile(f);
+  return ret;
+}
+
+MemoryBufferRef MemoryBuffer::GetMemBufferRef() const {
+  return MemoryBufferRef(GetBuffer(), GetBufferIdentifier());
+}
+
+SmallVectorMemoryBuffer::~SmallVectorMemoryBuffer() {}
diff --git a/wpiutil/src/main/native/cpp/llvm/SmallPtrSet.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallPtrSet.cpp
similarity index 97%
rename from wpiutil/src/main/native/cpp/llvm/SmallPtrSet.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallPtrSet.cpp
index 1b33f4c..f356728 100644
--- a/wpiutil/src/main/native/cpp/llvm/SmallPtrSet.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallPtrSet.cpp
@@ -1,9 +1,8 @@
 //===- llvm/ADT/SmallPtrSet.cpp - 'Normally small' pointer set ------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -16,7 +15,6 @@
 #include "wpi/DenseMapInfo.h"
 #include "wpi/MathExtras.h"
 #include "wpi/MemAlloc.h"
-#include "wpi/ErrorHandling.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
@@ -60,6 +58,7 @@
   else
     ++NumNonEmpty; // Track density.
   *Bucket = Ptr;
+  incrementEpoch();
   return std::make_pair(Bucket, true);
 }
 
diff --git a/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallVector.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallVector.cpp
new file mode 100644
index 0000000..04f4e06
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/SmallVector.cpp
@@ -0,0 +1,129 @@
+//===- llvm/ADT/SmallVector.cpp - 'Normally small' vectors ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the SmallVector class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SmallVector.h"
+#include "wpi/MemAlloc.h"
+#include <cstdint>
+#ifdef LLVM_ENABLE_EXCEPTIONS
+#include <stdexcept>
+#endif
+using namespace wpi;
+
+// Check that no bytes are wasted and everything is well-aligned.
+namespace {
+// These structures may cause binary compat warnings on AIX. Suppress the
+// warning since we are only using these types for the static assertions below.
+#if defined(_AIX)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waix-compat"
+#endif
+struct Struct16B {
+  alignas(16) void *X;
+};
+struct Struct32B {
+  alignas(32) void *X;
+};
+#if defined(_AIX)
+#pragma GCC diagnostic pop
+#endif
+}
+static_assert(sizeof(SmallVector<void *, 0>) ==
+                  sizeof(unsigned) * 2 + sizeof(void *),
+              "wasted space in SmallVector size 0");
+static_assert(alignof(SmallVector<Struct16B, 0>) >= alignof(Struct16B),
+              "wrong alignment for 16-byte aligned T");
+static_assert(alignof(SmallVector<Struct32B, 0>) >= alignof(Struct32B),
+              "wrong alignment for 32-byte aligned T");
+static_assert(sizeof(SmallVector<Struct16B, 0>) >= alignof(Struct16B),
+              "missing padding for 16-byte aligned T");
+static_assert(sizeof(SmallVector<Struct32B, 0>) >= alignof(Struct32B),
+              "missing padding for 32-byte aligned T");
+static_assert(sizeof(SmallVector<void *, 1>) ==
+                  sizeof(unsigned) * 2 + sizeof(void *) * 2,
+              "wasted space in SmallVector size 1");
+
+/// Report that MinSize doesn't fit into this vector's size type. Throws
+/// std::length_error or calls report_fatal_error.
+[[noreturn]] static void report_size_overflow(size_t MinSize, size_t MaxSize);
+static void report_size_overflow(size_t MinSize, size_t MaxSize) {
+  std::string Reason = "SmallVector unable to grow. Requested capacity (" +
+                       std::to_string(MinSize) +
+                       ") is larger than maximum value for size type (" +
+                       std::to_string(MaxSize) + ")";
+#ifdef LLVM_ENABLE_EXCEPTIONS
+  throw std::length_error(Reason);
+#else
+  report_fatal_error(Reason);
+#endif
+}
+
+/// Report that this vector is already at maximum capacity. Throws
+/// std::length_error or calls report_fatal_error.
+[[noreturn]] static void report_at_maximum_capacity(size_t MaxSize);
+static void report_at_maximum_capacity(size_t MaxSize) {
+  std::string Reason =
+      "SmallVector capacity unable to grow. Already at maximum size " +
+      std::to_string(MaxSize);
+#ifdef LLVM_ENABLE_EXCEPTIONS
+  throw std::length_error(Reason);
+#else
+  report_fatal_error(Reason);
+#endif
+}
+
+// Note: Moving this function into the header may cause performance regression.
+static size_t getNewCapacity(size_t MinSize, size_t TSize, size_t OldCapacity) {
+  constexpr size_t MaxSize = std::numeric_limits<unsigned>::max();
+
+  // Ensure we can fit the new capacity.
+  // This is only going to be applicable when the capacity is 32 bit.
+  if (MinSize > MaxSize)
+    report_size_overflow(MinSize, MaxSize);
+
+  // Ensure we can meet the guarantee of space for at least one more element.
+  // The above check alone will not catch the case where grow is called with a
+  // default MinSize of 0, but the current capacity cannot be increased.
+  // This is only going to be applicable when the capacity is 32 bit.
+  if (OldCapacity == MaxSize)
+    report_at_maximum_capacity(MaxSize);
+
+  // In theory 2*capacity can overflow if the capacity is 64 bit, but the
+  // original capacity would never be large enough for this to be a problem.
+  size_t NewCapacity = 2 * OldCapacity + 1; // Always grow.
+  return (std::min)((std::max)(NewCapacity, MinSize), MaxSize);
+}
+
+// Note: Moving this function into the header may cause performance regression.
+void *SmallVectorBase::mallocForGrow(size_t MinSize, size_t TSize,
+                                             size_t &NewCapacity) {
+  NewCapacity = getNewCapacity(MinSize, TSize, this->capacity());
+  return wpi::safe_malloc(NewCapacity * TSize);
+}
+
+// Note: Moving this function into the header may cause performance regression.
+void SmallVectorBase::grow_pod(void *FirstEl, size_t MinSize,
+                                       size_t TSize) {
+  size_t NewCapacity = getNewCapacity(MinSize, TSize, this->capacity());
+  void *NewElts;
+  if (BeginX == FirstEl) {
+    NewElts = safe_malloc(NewCapacity * TSize);
+
+    // Copy the elements over.  No need to run dtors on PODs.
+    memcpy(NewElts, this->BeginX, size() * TSize);
+  } else {
+    // If this wasn't grown from the inline copy, grow the allocated space.
+    NewElts = safe_realloc(this->BeginX, NewCapacity * TSize);
+  }
+
+  this->BeginX = NewElts;
+  this->Capacity = NewCapacity;
+}
diff --git a/wpiutil/src/main/native/cpp/StringExtras.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringExtras.cpp
similarity index 83%
rename from wpiutil/src/main/native/cpp/StringExtras.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringExtras.cpp
index 968ffc3..9307724 100644
--- a/wpiutil/src/main/native/cpp/StringExtras.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringExtras.cpp
@@ -358,3 +358,85 @@
   }
   return val;
 }
+
+std::pair<std::string_view, std::string_view> wpi::UnescapeCString(
+    std::string_view str, wpi::SmallVectorImpl<char>& buf) {
+  buf.clear();
+  buf.reserve(str.size());
+  const char* s = str.data();
+  const char* end = str.data() + str.size();
+  for (; s != end && *s != '"'; ++s) {
+    if (*s != '\\' || (s + 1) >= end) {
+      buf.push_back(*s);
+      continue;
+    }
+    switch (*++s) {
+      case 'a':
+        buf.push_back('\a');
+        break;
+      case 'b':
+        buf.push_back('\b');
+        break;
+      case 'f':
+        buf.push_back('\f');
+        break;
+      case 'n':
+        buf.push_back('\n');
+        break;
+      case 'r':
+        buf.push_back('\r');
+        break;
+      case 't':
+        buf.push_back('\t');
+        break;
+      case 'v':
+        buf.push_back('\v');
+        break;
+      case 'x': {
+        // hex escape
+        if ((s + 1) >= end || !isxdigit(*(s + 1))) {
+          buf.push_back('x');  // treat it like a unknown escape
+          break;
+        }
+        unsigned int ch = wpi::hexDigitValue(*++s);
+        if ((s + 1) < end && std::isxdigit(*(s + 1))) {
+          ch <<= 4;
+          ch |= wpi::hexDigitValue(*++s);
+        }
+        buf.push_back(static_cast<char>(ch));
+        break;
+      }
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9': {
+        // octal escape
+        unsigned int ch = *s - '0';
+        if ((s + 1) < end && wpi::isDigit(*(s + 1))) {
+          ch <<= 3;
+          ch |= *++s - '0';
+        }
+        if ((s + 1) < end && wpi::isDigit(*(s + 1))) {
+          ch <<= 3;
+          ch |= *++s - '0';
+        }
+        buf.push_back(static_cast<char>(ch));
+        break;
+      }
+      default:
+        buf.push_back(*s);
+        break;
+    }
+  }
+  if (s == end) {
+    return {{buf.data(), buf.size()}, {}};
+  } else {
+    return {{buf.data(), buf.size()}, {s, static_cast<size_t>(end - s)}};
+  }
+}
diff --git a/wpiutil/src/main/native/cpp/llvm/StringMap.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringMap.cpp
similarity index 78%
rename from wpiutil/src/main/native/cpp/llvm/StringMap.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringMap.cpp
index 768801d..2405f2f 100644
--- a/wpiutil/src/main/native/cpp/llvm/StringMap.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/StringMap.cpp
@@ -1,9 +1,8 @@
 //===--- StringMap.cpp - String Hash table map implementation -------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -12,28 +11,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "wpi/StringMap.h"
-#include "wpi/StringExtras.h"
-#include "wpi/Compiler.h"
+#include "wpi/DJB.h"
 #include "wpi/MathExtras.h"
-#include <cassert>
 
 using namespace wpi;
 
-/// HashString - Hash function for strings.
-///
-/// This is the Bernstein hash function.
-//
-// FIXME: Investigate whether a modified bernstein hash function performs
-// better: http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
-//   X*33+c -> X*33^c
-static inline unsigned HashString(std::string_view str,
-                                  unsigned result = 0) noexcept {
-  for (std::string_view::size_type i = 0, e = str.size(); i != e; ++i) {
-    result = result * 33 + static_cast<unsigned char>(str[i]);
-  }
-  return result;
-}
-
 /// Returns the number of buckets to allocate to ensure that the DenseMap can
 /// accommodate \p NumEntries without need to grow().
 static unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
@@ -65,23 +47,22 @@
 }
 
 void StringMapImpl::init(unsigned InitSize) {
-  assert((InitSize & (InitSize-1)) == 0 &&
+  assert((InitSize & (InitSize - 1)) == 0 &&
          "Init Size must be a power of 2 or zero!");
 
   unsigned NewNumBuckets = InitSize ? InitSize : 16;
   NumItems = 0;
   NumTombstones = 0;
 
-  TheTable = static_cast<StringMapEntryBase **>(
-      safe_calloc(NewNumBuckets+1,
-                  sizeof(StringMapEntryBase **) + sizeof(unsigned)));
+  TheTable = static_cast<StringMapEntryBase **>(safe_calloc(
+      NewNumBuckets + 1, sizeof(StringMapEntryBase **) + sizeof(unsigned)));
 
   // Set the member only if TheTable was successfully allocated
   NumBuckets = NewNumBuckets;
 
   // Allocate one extra bucket, set it to look filled so the iterators stop at
   // end.
-  TheTable[NumBuckets] = (StringMapEntryBase*)2;
+  TheTable[NumBuckets] = (StringMapEntryBase *)2;
 }
 
 /// LookupBucketFor - Look up the bucket that the specified string should end
@@ -91,12 +72,12 @@
 /// of the string.
 unsigned StringMapImpl::LookupBucketFor(std::string_view Name) {
   unsigned HTSize = NumBuckets;
-  if (HTSize == 0) {  // Hash table unallocated so far?
+  if (HTSize == 0) { // Hash table unallocated so far?
     init(16);
     HTSize = NumBuckets;
   }
-  unsigned FullHashValue = HashString(Name);
-  unsigned BucketNo = FullHashValue & (HTSize-1);
+  unsigned FullHashValue = djbHash(Name, 0);
+  unsigned BucketNo = FullHashValue & (HTSize - 1);
   unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
 
   unsigned ProbeAmt = 1;
@@ -118,7 +99,8 @@
 
     if (BucketItem == getTombstoneVal()) {
       // Skip over tombstones.  However, remember the first one we see.
-      if (FirstTombstone == -1) FirstTombstone = BucketNo;
+      if (FirstTombstone == -1)
+        FirstTombstone = BucketNo;
     } else if (LLVM_LIKELY(HashTable[BucketNo] == FullHashValue)) {
       // If the full hash value matches, check deeply for a match.  The common
       // case here is that we are only looking at the buckets (for item info
@@ -127,7 +109,7 @@
 
       // Do the comparison like this because Name isn't necessarily
       // null-terminated!
-      char *ItemStr = (char*)BucketItem+ItemSize;
+      char *ItemStr = (char *)BucketItem + ItemSize;
       if (Name == std::string_view(ItemStr, BucketItem->getKeyLength())) {
         // We found a match!
         return BucketNo;
@@ -135,7 +117,7 @@
     }
 
     // Okay, we didn't find the item.  Probe to the next bucket.
-    BucketNo = (BucketNo+ProbeAmt) & (HTSize-1);
+    BucketNo = (BucketNo + ProbeAmt) & (HTSize - 1);
 
     // Use quadratic probing, it has fewer clumping artifacts than linear
     // probing and has good cache behavior in the common case.
@@ -148,9 +130,10 @@
 /// This does not modify the map.
 int StringMapImpl::FindKey(std::string_view Key) const {
   unsigned HTSize = NumBuckets;
-  if (HTSize == 0) return -1;  // Really empty table?
-  unsigned FullHashValue = HashString(Key);
-  unsigned BucketNo = FullHashValue & (HTSize-1);
+  if (HTSize == 0)
+    return -1; // Really empty table?
+  unsigned FullHashValue = djbHash(Key, 0);
+  unsigned BucketNo = FullHashValue & (HTSize - 1);
   unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
 
   unsigned ProbeAmt = 1;
@@ -170,7 +153,7 @@
 
       // Do the comparison like this because NameStart isn't necessarily
       // null-terminated!
-      char *ItemStr = (char*)BucketItem+ItemSize;
+      char *ItemStr = (char *)BucketItem + ItemSize;
       if (Key == std::string_view(ItemStr, BucketItem->getKeyLength())) {
         // We found a match!
         return BucketNo;
@@ -178,7 +161,7 @@
     }
 
     // Okay, we didn't find the item.  Probe to the next bucket.
-    BucketNo = (BucketNo+ProbeAmt) & (HTSize-1);
+    BucketNo = (BucketNo + ProbeAmt) & (HTSize - 1);
 
     // Use quadratic probing, it has fewer clumping artifacts than linear
     // probing and has good cache behavior in the common case.
@@ -189,7 +172,7 @@
 /// RemoveKey - Remove the specified StringMapEntry from the table, but do not
 /// delete it.  This aborts if the value isn't in the table.
 void StringMapImpl::RemoveKey(StringMapEntryBase *V) {
-  const char *VStr = (char*)V + ItemSize;
+  const char *VStr = (char *)V + ItemSize;
   StringMapEntryBase *V2 = RemoveKey(std::string_view(VStr, V->getKeyLength()));
   (void)V2;
   assert(V == V2 && "Didn't find key?");
@@ -199,7 +182,8 @@
 /// table, returning it.  If the key is not in the table, this returns null.
 StringMapEntryBase *StringMapImpl::RemoveKey(std::string_view Key) {
   int Bucket = FindKey(Key);
-  if (Bucket == -1) return nullptr;
+  if (Bucket == -1)
+    return nullptr;
 
   StringMapEntryBase *Result = TheTable[Bucket];
   TheTable[Bucket] = getTombstoneVal();
@@ -220,7 +204,7 @@
   // the buckets are empty (meaning that many are filled with tombstones),
   // grow/rehash the table.
   if (LLVM_UNLIKELY(NumItems * 4 > NumBuckets * 3)) {
-    NewSize = NumBuckets*2;
+    NewSize = NumBuckets * 2;
   } else if (LLVM_UNLIKELY(NumBuckets - (NumItems + NumTombstones) <=
                            NumBuckets / 8)) {
     NewSize = NumBuckets;
@@ -231,11 +215,11 @@
   unsigned NewBucketNo = BucketNo;
   // Allocate one extra bucket which will always be non-empty.  This allows the
   // iterators to stop at end.
-  auto NewTableArray = static_cast<StringMapEntryBase **>(
-      safe_calloc(NewSize+1, sizeof(StringMapEntryBase *) + sizeof(unsigned)));
+  auto NewTableArray = static_cast<StringMapEntryBase **>(safe_calloc(
+      NewSize + 1, sizeof(StringMapEntryBase *) + sizeof(unsigned)));
 
   unsigned *NewHashArray = (unsigned *)(NewTableArray + NewSize + 1);
-  NewTableArray[NewSize] = (StringMapEntryBase*)2;
+  NewTableArray[NewSize] = (StringMapEntryBase *)2;
 
   // Rehash all the items into their new buckets.  Luckily :) we already have
   // the hash values available, so we don't have to rehash any strings.
@@ -244,10 +228,10 @@
     if (Bucket && Bucket != getTombstoneVal()) {
       // Fast case, bucket available.
       unsigned FullHash = HashTable[I];
-      unsigned NewBucket = FullHash & (NewSize-1);
+      unsigned NewBucket = FullHash & (NewSize - 1);
       if (!NewTableArray[NewBucket]) {
-        NewTableArray[FullHash & (NewSize-1)] = Bucket;
-        NewHashArray[FullHash & (NewSize-1)] = FullHash;
+        NewTableArray[FullHash & (NewSize - 1)] = Bucket;
+        NewHashArray[FullHash & (NewSize - 1)] = FullHash;
         if (I == BucketNo)
           NewBucketNo = NewBucket;
         continue;
@@ -256,7 +240,7 @@
       // Otherwise probe for a spot.
       unsigned ProbeSize = 1;
       do {
-        NewBucket = (NewBucket + ProbeSize++) & (NewSize-1);
+        NewBucket = (NewBucket + ProbeSize++) & (NewSize - 1);
       } while (NewTableArray[NewBucket]);
 
       // Finally found a slot.  Fill it in.
diff --git a/wpiutil/src/main/native/cpp/llvm/Windows/WindowsSupport.h b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Windows/WindowsSupport.h
similarity index 82%
rename from wpiutil/src/main/native/cpp/llvm/Windows/WindowsSupport.h
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Windows/WindowsSupport.h
index 7307337..01200e2 100644
--- a/wpiutil/src/main/native/cpp/llvm/Windows/WindowsSupport.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/Windows/WindowsSupport.h
@@ -1,9 +1,8 @@
 //===- WindowsSupport.h - Common Windows Include File -----------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -19,8 +18,8 @@
 //===          is guaranteed to work on *all* Win32 variants.
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_WINDOWSSUPPORT_H
-#define LLVM_SUPPORT_WINDOWSSUPPORT_H
+#ifndef WPIUTIL_WPI_WINDOWSSUPPORT_H
+#define WPIUTIL_WPI_WINDOWSSUPPORT_H
 
 // mingw-w64 tends to define it as 0x0502 in its headers.
 #undef _WIN32_WINNT
@@ -38,10 +37,10 @@
 #include "wpi/StringExtras.h"
 #include "wpi/Chrono.h"
 #include "wpi/Compiler.h"
+#include "wpi/ErrorHandling.h"
 #include "wpi/VersionTuple.h"
 #include <cassert>
 #include <string>
-#include <string_view>
 #include <system_error>
 #define WIN32_NO_STATUS
 #include <windows.h>
@@ -49,6 +48,9 @@
 #include <winternl.h>
 #include <ntstatus.h>
 
+// Must be included after windows.h
+#include <wincrypt.h>
+
 namespace wpi {
 
 /// Returns the Windows version as Major.Minor.0.BuildNumber. Uses
@@ -81,23 +83,19 @@
   return GetWindowsOSVersion() >= wpi::VersionTuple(6, 2, 0, 0);
 }
 
-inline bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix) {
-  if (!ErrMsg)
-    return true;
-  char *buffer = NULL;
-  DWORD LastError = GetLastError();
-  DWORD R = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                               FORMAT_MESSAGE_FROM_SYSTEM |
-                               FORMAT_MESSAGE_MAX_WIDTH_MASK,
-                           NULL, LastError, 0, (LPSTR)&buffer, 1, NULL);
-  if (R)
-    *ErrMsg = prefix + ": " + buffer;
-  else
-    *ErrMsg = prefix + ": Unknown error";
-  *ErrMsg += " (0x" + wpi::utohexstr(LastError) + ")";
+/// Returns the Windows version as Major.Minor.0.BuildNumber. Uses
+/// RtlGetVersion or GetVersionEx under the hood depending on what is available.
+/// GetVersionEx is deprecated, but this API exposes the build number which can
+/// be useful for working around certain kernel bugs.
+wpi::VersionTuple GetWindowsOSVersion();
 
-  LocalFree(buffer);
-  return R != 0;
+bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix);
+
+// Include GetLastError() in a fatal error message.
+[[noreturn]] inline void ReportLastErrorFatal(const char *Msg) {
+  std::string ErrMsg;
+  MakeErrMsg(&ErrMsg, Msg);
+  wpi::report_fatal_error(ErrMsg);
 }
 
 template <typename HandleTraits>
@@ -164,6 +162,22 @@
   }
 };
 
+struct CryptContextTraits : CommonHandleTraits {
+  typedef HCRYPTPROV handle_type;
+
+  static handle_type GetInvalid() {
+    return 0;
+  }
+
+  static void Close(handle_type h) {
+    ::CryptReleaseContext(h, 0);
+  }
+
+  static bool IsValid(handle_type h) {
+    return h != GetInvalid();
+  }
+};
+
 struct RegTraits : CommonHandleTraits {
   typedef HKEY handle_type;
 
@@ -190,6 +204,7 @@
 
 typedef ScopedHandle<CommonHandleTraits> ScopedCommonHandle;
 typedef ScopedHandle<FileHandleTraits>   ScopedFileHandle;
+typedef ScopedHandle<CryptContextTraits> ScopedCryptContext;
 typedef ScopedHandle<RegTraits>          ScopedRegHandle;
 typedef ScopedHandle<FindHandleTraits>   ScopedFindHandle;
 typedef ScopedHandle<JobHandleTraits>    ScopedJobHandle;
diff --git a/wpiutil/src/main/native/cpp/llvm/raw_os_ostream.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_os_ostream.cpp
similarity index 79%
rename from wpiutil/src/main/native/cpp/llvm/raw_os_ostream.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_os_ostream.cpp
index 1fb6c51..682a9a0 100644
--- a/wpiutil/src/main/native/cpp/llvm/raw_os_ostream.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_os_ostream.cpp
@@ -1,9 +1,8 @@
 //===--- raw_os_ostream.cpp - Implement the raw_os_ostream class ----------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/wpiutil/src/main/native/cpp/llvm/raw_ostream.cpp b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_ostream.cpp
similarity index 87%
rename from wpiutil/src/main/native/cpp/llvm/raw_ostream.cpp
rename to wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_ostream.cpp
index 622e0bf..a2d586b 100644
--- a/wpiutil/src/main/native/cpp/llvm/raw_ostream.cpp
+++ b/wpiutil/src/main/native/thirdparty/llvm/cpp/llvm/raw_ostream.cpp
@@ -1,9 +1,8 @@
 //===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -21,19 +20,15 @@
 #include "wpi/StringExtras.h"
 #include "wpi/Compiler.h"
 #include "wpi/ErrorHandling.h"
-#include "wpi/MathExtras.h"
-#include "wpi/WindowsError.h"
 #include "wpi/fs.h"
+#include "wpi/MathExtras.h"
 #include <algorithm>
-#include <cctype>
 #include <cerrno>
 #include <cstdio>
-#include <iterator>
 #include <sys/stat.h>
-#include <system_error>
 
 // <fcntl.h> may provide O_BINARY.
-#include <fcntl.h>
+# include <fcntl.h>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -64,6 +59,17 @@
 
 using namespace wpi;
 
+constexpr raw_ostream::Colors raw_ostream::BLACK;
+constexpr raw_ostream::Colors raw_ostream::RED;
+constexpr raw_ostream::Colors raw_ostream::GREEN;
+constexpr raw_ostream::Colors raw_ostream::YELLOW;
+constexpr raw_ostream::Colors raw_ostream::BLUE;
+constexpr raw_ostream::Colors raw_ostream::MAGENTA;
+constexpr raw_ostream::Colors raw_ostream::CYAN;
+constexpr raw_ostream::Colors raw_ostream::WHITE;
+constexpr raw_ostream::Colors raw_ostream::SAVEDCOLOR;
+constexpr raw_ostream::Colors raw_ostream::RESET;
+
 namespace {
 // Find the length of an array.
 template <class T, std::size_t N>
@@ -78,13 +84,10 @@
   assert(OutBufCur == OutBufStart &&
          "raw_ostream destructor called with non-empty buffer!");
 
-  if (BufferMode == InternalBuffer)
+  if (BufferMode == BufferKind::InternalBuffer)
     delete [] OutBufStart;
 }
 
-// An out of line virtual method to provide a home for the class vtable.
-void raw_ostream::handle() {}
-
 size_t raw_ostream::preferred_buffer_size() const {
   // BUFSIZ is intended to be a reasonable default.
   return BUFSIZ;
@@ -101,14 +104,14 @@
 
 void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
                                    BufferKind Mode) {
-  assert(((Mode == Unbuffered && !BufferStart && Size == 0) ||
-          (Mode != Unbuffered && BufferStart && Size != 0)) &&
+  assert(((Mode == BufferKind::Unbuffered && !BufferStart && Size == 0) ||
+          (Mode != BufferKind::Unbuffered && BufferStart && Size != 0)) &&
          "stream must be unbuffered or have at least one byte");
   // Make sure the current buffer is free of content (we can't flush here; the
   // child buffer management logic will be in write_impl).
   assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
 
-  if (BufferMode == InternalBuffer)
+  if (BufferMode == BufferKind::InternalBuffer)
     delete [] OutBufStart;
   OutBufStart = BufferStart;
   OutBufEnd = OutBufStart+Size;
@@ -143,7 +146,7 @@
       // Write out the escaped representation.
       if (UseHexEscapes) {
         *this << '\\' << 'x';
-        *this << hexdigit((c >> 4 & 0xF));
+        *this << hexdigit((c >> 4) & 0xF);
         *this << hexdigit((c >> 0) & 0xF);
       } else {
         // Always use a full 3-character octal escape.
@@ -162,15 +165,15 @@
   assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
   size_t Length = OutBufCur - OutBufStart;
   OutBufCur = OutBufStart;
-  write_impl(OutBufStart, Length);
+  flush_tied_then_write(OutBufStart, Length);
 }
 
 raw_ostream &raw_ostream::write(unsigned char C) {
   // Group exceptional cases into a single branch.
   if (LLVM_UNLIKELY(OutBufCur >= OutBufEnd)) {
     if (LLVM_UNLIKELY(!OutBufStart)) {
-      if (BufferMode == Unbuffered) {
-        write_impl(reinterpret_cast<char*>(&C), 1);
+      if (BufferMode == BufferKind::Unbuffered) {
+        flush_tied_then_write(reinterpret_cast<char *>(&C), 1);
         return *this;
       }
       // Set up a buffer and start over.
@@ -189,8 +192,8 @@
   // Group exceptional cases into a single branch.
   if (LLVM_UNLIKELY(size_t(OutBufEnd - OutBufCur) < Size)) {
     if (LLVM_UNLIKELY(!OutBufStart)) {
-      if (BufferMode == Unbuffered) {
-        write_impl(Ptr, Size);
+      if (BufferMode == BufferKind::Unbuffered) {
+        flush_tied_then_write(Ptr, Size);
         return *this;
       }
       // Set up a buffer and start over.
@@ -206,7 +209,7 @@
     if (LLVM_UNLIKELY(OutBufCur == OutBufStart)) {
       assert(NumBytes != 0 && "undefined behavior");
       size_t BytesToWrite = Size - (Size % NumBytes);
-      write_impl(Ptr, BytesToWrite);
+      flush_tied_then_write(Ptr, BytesToWrite);
       size_t BytesRemaining = Size - BytesToWrite;
       if (BytesRemaining > size_t(OutBufEnd - OutBufCur)) {
         // Too much left over to copy into our buffer.
@@ -247,6 +250,13 @@
   OutBufCur += Size;
 }
 
+void raw_ostream::flush_tied_then_write(const char *Ptr, size_t Size) {
+  if (TiedStream)
+    TiedStream->flush();
+  write_impl(Ptr, Size);
+}
+
+
 template <char C>
 static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) {
   static const char Chars[] = {C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
@@ -294,8 +304,7 @@
   // the owner of stdout and may set the "binary" flag globally based on Flags.
   if (Filename == "-") {
     EC = std::error_code();
-    // If user requested binary then put stdout into binary mode if
-    // possible.
+    // Change stdout's text/binary mode based on the Flags.
     if (!(Flags & fs::OF_Text)) {
 #if defined(_WIN32)
       _setmode(_fileno(stdout), _O_BINARY);
@@ -305,11 +314,10 @@
   }
 
   fs::file_t F;
-  if (Access & fs::FA_Read) {
+  if (Access & fs::FA_Read)
     F = fs::OpenFileForReadWrite(fs::path{std::string_view{Filename.data(), Filename.size()}}, EC, Disp, Flags);
-  } else {
+  else
     F = fs::OpenFileForWrite(fs::path{std::string_view{Filename.data(), Filename.size()}}, EC, Disp, Flags);
-  }
   if (EC)
     return -1;
   int FD = fs::FileToFd(F, EC, Flags);
@@ -345,13 +353,16 @@
 
 /// FD is the file descriptor that this writes to.  If ShouldClose is true, this
 /// closes the file when the stream is destroyed.
-raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered)
-    : raw_pwrite_stream(unbuffered), FD(fd), ShouldClose(shouldClose) {
+raw_fd_ostream::raw_fd_ostream(int fd, bool shouldClose, bool unbuffered,
+                               OStreamKind K)
+    : raw_pwrite_stream(unbuffered, K), FD(fd), ShouldClose(shouldClose) {
   if (FD < 0 ) {
     ShouldClose = false;
     return;
   }
 
+  enable_colors(true);
+
   // Do not attempt to close stdout or stderr. We used to try to maintain the
   // property that tools that support writing file to stdout should not also
   // write informational output to stdout, but in practice we were never able to
@@ -370,10 +381,9 @@
   // Get the starting position.
   off_t loc = ::lseek(FD, 0, SEEK_CUR);
 #ifdef _WIN32
-  // MSVCRT's _lseek(SEEK_CUR) doesn't return -1 for pipes.
   SupportsSeeking = loc != (off_t)-1 && ::GetFileType(reinterpret_cast<HANDLE>(::_get_osfhandle(FD))) != FILE_TYPE_PIPE;
 #else
-  SupportsSeeking = loc != (off_t)-1;
+  SupportsSeeking = !EC && loc != (off_t)-1;
 #endif
   if (!SupportsSeeking)
     pos = 0;
@@ -402,7 +412,7 @@
   // destructing raw_ostream objects which may have errors.
   if (has_error())
     report_fatal_error("IO failure on output stream: " + error().message(),
-                       /*GenCrashDiag=*/false);
+                       /*gen_crash_diag=*/false);
 }
 
 #if defined(_WIN32)
@@ -565,7 +575,7 @@
   // If this is a terminal, don't use buffering. Line buffering
   // would be a more traditional thing to do, but it's not worth
   // the complexity.
-  if (S_ISCHR(statbuf.st_mode) && isatty(FD))
+  if (S_ISCHR(statbuf.st_mode) && is_displayed())
     return 0;
   // Return the preferred block size.
   return statbuf.st_blksize;
@@ -580,38 +590,50 @@
 //  outs(), errs(), nulls()
 //===----------------------------------------------------------------------===//
 
-/// outs() - This returns a reference to a raw_ostream for standard output.
-/// Use it like: outs() << "foo" << "bar";
-raw_ostream &wpi::outs() {
+raw_fd_ostream &wpi::outs() {
   // Set buffer settings to model stdout behavior.
   std::error_code EC;
-  static raw_fd_ostream* S = new raw_fd_ostream("-", EC, fs::F_None);
+  static raw_fd_ostream* S = new raw_fd_ostream("-", EC, fs::OF_None);
   assert(!EC);
   return *S;
 }
 
-/// errs() - This returns a reference to a raw_ostream for standard error.
-/// Use it like: errs() << "foo" << "bar";
-raw_ostream &wpi::errs() {
-  // Set standard error to be unbuffered by default.
+raw_fd_ostream &wpi::errs() {
+  // Set standard error to be unbuffered and tied to outs() by default.
   static raw_fd_ostream* S = new raw_fd_ostream(STDERR_FILENO, false, true);
   return *S;
 }
 
 /// nulls() - This returns a reference to a raw_ostream which discards output.
 raw_ostream &wpi::nulls() {
-  static raw_null_ostream* S = new raw_null_ostream;
-  return *S;
+  static raw_null_ostream S;
+  return S;
+}
+
+//===----------------------------------------------------------------------===//
+// File Streams
+//===----------------------------------------------------------------------===//
+
+raw_fd_stream::raw_fd_stream(std::string_view Filename, std::error_code &EC)
+    : raw_fd_ostream(getFD(Filename, EC, fs::CD_CreateAlways,
+                           fs::FA_Write | fs::FA_Read,
+                           fs::OF_None),
+                     true, false, OStreamKind::OK_FDStream) {
+  if (EC)
+    return;
+
+  if (!isRegularFile())
+    EC = std::make_error_code(std::errc::invalid_argument);
+}
+
+bool raw_fd_stream::classof(const raw_ostream *OS) {
+  return OS->get_kind() == OStreamKind::OK_FDStream;
 }
 
 //===----------------------------------------------------------------------===//
 //  raw_string_ostream
 //===----------------------------------------------------------------------===//
 
-raw_string_ostream::~raw_string_ostream() {
-  flush();
-}
-
 void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
   OS.append(Ptr, Size);
 }
@@ -691,15 +713,18 @@
 #endif
 }
 
-void raw_null_ostream::write_impl(const char * /*Ptr*/, size_t /*Size*/) {}
+void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
+}
 
 uint64_t raw_null_ostream::current_pos() const {
   return 0;
 }
 
-void raw_null_ostream::pwrite_impl(const char * /*Ptr*/, size_t /*Size*/,
-                                   uint64_t /*Offset*/) {}
+void raw_null_ostream::pwrite_impl(const char *Ptr, size_t Size,
+                                   uint64_t Offset) {}
 
 void raw_pwrite_stream::anchor() {}
 
 void buffer_ostream::anchor() {}
+
+void buffer_unique_ostream::anchor() {}
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AlignOf.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AlignOf.h
new file mode 100644
index 0000000..5d400e4
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AlignOf.h
@@ -0,0 +1,34 @@
+//===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AlignedCharArrayUnion class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_ALIGNOF_H
+#define WPIUTIL_WPI_ALIGNOF_H
+
+#include <type_traits>
+
+namespace wpi {
+
+/// A suitably aligned and sized character array member which can hold elements
+/// of any type.
+///
+/// This template is equivalent to std::aligned_union_t<1, ...>, but we cannot
+/// use it due to a bug in the MSVC x86 compiler:
+/// https://github.com/microsoft/STL/issues/1533
+/// Using `alignas` here works around the bug.
+template <typename T, typename... Ts> struct AlignedCharArrayUnion {
+  using AlignedUnion = std::aligned_union_t<1, T, Ts...>;
+  alignas(alignof(AlignedUnion)) char buffer[sizeof(AlignedUnion)];
+};
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_ALIGNOF_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AllocatorBase.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AllocatorBase.h
new file mode 100644
index 0000000..29ba16f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/AllocatorBase.h
@@ -0,0 +1,104 @@
+//===- AllocatorBase.h - Simple memory allocation abstraction ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines MallocAllocator. MallocAllocator conforms to the LLVM
+/// "Allocator" concept which consists of an Allocate method accepting a size
+/// and alignment, and a Deallocate accepting a pointer and size. Further, the
+/// LLVM "Allocator" concept has overloads of Allocate and Deallocate for
+/// setting size and alignment based on the final type. These overloads are
+/// typically provided by a base class template \c AllocatorBase.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_ALLOCATORBASE_H
+#define WPIUTIL_WPI_ALLOCATORBASE_H
+
+#include "wpi/Compiler.h"
+#include "wpi/MemAlloc.h"
+#include <type_traits>
+
+namespace wpi {
+
+/// CRTP base class providing obvious overloads for the core \c
+/// Allocate() methods of LLVM-style allocators.
+///
+/// This base class both documents the full public interface exposed by all
+/// LLVM-style allocators, and redirects all of the overloads to a single core
+/// set of methods which the derived class must define.
+template <typename DerivedT> class AllocatorBase {
+public:
+  /// Allocate \a Size bytes of \a Alignment aligned memory. This method
+  /// must be implemented by \c DerivedT.
+  void *Allocate(size_t Size, size_t Alignment) {
+#ifdef __clang__
+    static_assert(static_cast<void *(AllocatorBase::*)(size_t, size_t)>(
+                      &AllocatorBase::Allocate) !=
+                      static_cast<void *(DerivedT::*)(size_t, size_t)>(
+                          &DerivedT::Allocate),
+                  "Class derives from AllocatorBase without implementing the "
+                  "core Allocate(size_t, size_t) overload!");
+#endif
+    return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
+  }
+
+  /// Deallocate \a Ptr to \a Size bytes of memory allocated by this
+  /// allocator.
+  void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
+#ifdef __clang__
+    static_assert(
+        static_cast<void (AllocatorBase::*)(const void *, size_t, size_t)>(
+            &AllocatorBase::Deallocate) !=
+            static_cast<void (DerivedT::*)(const void *, size_t, size_t)>(
+                &DerivedT::Deallocate),
+        "Class derives from AllocatorBase without implementing the "
+        "core Deallocate(void *) overload!");
+#endif
+    return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size, Alignment);
+  }
+
+  // The rest of these methods are helpers that redirect to one of the above
+  // core methods.
+
+  /// Allocate space for a sequence of objects without constructing them.
+  template <typename T> T *Allocate(size_t Num = 1) {
+    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
+  }
+
+  /// Deallocate space for a sequence of objects without constructing them.
+  template <typename T>
+  std::enable_if_t<!std::is_same<std::remove_cv_t<T>, void>::value, void>
+  Deallocate(T *Ptr, size_t Num = 1) {
+    Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T), alignof(T));
+  }
+};
+
+class MallocAllocator : public AllocatorBase<MallocAllocator> {
+public:
+  void Reset() {}
+
+  LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
+    return allocate_buffer(Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Allocate;
+
+  void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
+    deallocate_buffer(const_cast<void *>(Ptr), Size, Alignment);
+  }
+
+  // Pull in base class overloads.
+  using AllocatorBase<MallocAllocator>::Deallocate;
+
+  void PrintStats() const {}
+};
+
+} // namespace wpi
+
+#endif // WPIUTIL_WPI_ALLOCATORBASE_H
diff --git a/wpiutil/src/main/native/include/wpi/Chrono.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Chrono.h
similarity index 70%
rename from wpiutil/src/main/native/include/wpi/Chrono.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/Chrono.h
index 33341c6..221f6dc 100644
--- a/wpiutil/src/main/native/include/wpi/Chrono.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Chrono.h
@@ -1,9 +1,8 @@
 //===- llvm/Support/Chrono.h - Utilities for Timing Manipulation-*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -14,6 +13,7 @@
 
 #include <chrono>
 #include <ctime>
+#include <ratio>
 
 namespace wpi {
 
@@ -23,31 +23,31 @@
 
 /// A time point on the system clock. This is provided for two reasons:
 /// - to insulate us against subtle differences in behavior to differences in
-///   system clock precision (which is implementation-defined and differs between
-///   platforms).
+///   system clock precision (which is implementation-defined and differs
+///   between platforms).
 /// - to shorten the type name
-/// The default precision is nanoseconds. If need a specific precision specify
-/// it explicitly. If unsure, use the default. If you need a time point on a
-/// clock other than the system_clock, use std::chrono directly.
+/// The default precision is nanoseconds. If you need a specific precision
+/// specify it explicitly. If unsure, use the default. If you need a time point
+/// on a clock other than the system_clock, use std::chrono directly.
 template <typename D = std::chrono::nanoseconds>
 using TimePoint = std::chrono::time_point<std::chrono::system_clock, D>;
 
 /// Convert a TimePoint to std::time_t
-LLVM_ATTRIBUTE_ALWAYS_INLINE std::time_t toTimeT(TimePoint<> TP) {
+inline std::time_t toTimeT(TimePoint<> TP) {
   using namespace std::chrono;
   return system_clock::to_time_t(
       time_point_cast<system_clock::time_point::duration>(TP));
 }
 
 /// Convert a std::time_t to a TimePoint
-LLVM_ATTRIBUTE_ALWAYS_INLINE TimePoint<std::chrono::seconds>
+inline TimePoint<std::chrono::seconds>
 toTimePoint(std::time_t T) {
   using namespace std::chrono;
   return time_point_cast<seconds>(system_clock::from_time_t(T));
 }
 
 /// Convert a std::time_t + nanoseconds to a TimePoint
-LLVM_ATTRIBUTE_ALWAYS_INLINE TimePoint<>
+inline TimePoint<>
 toTimePoint(std::time_t T, uint32_t nsec) {
   using namespace std::chrono;
   return time_point_cast<nanoseconds>(system_clock::from_time_t(T))
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Compiler.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Compiler.h
new file mode 100644
index 0000000..c98386e
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Compiler.h
@@ -0,0 +1,619 @@
+//===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines several macros, based on the current compiler.  This allows
+// use of compiler-specific features in a way that remains portable. This header
+// can be included from either C or C++.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_COMPILER_H
+#define WPIUTIL_WPI_COMPILER_H
+
+
+#include <stddef.h>
+
+#if defined(_MSC_VER)
+#include <sal.h>
+#endif
+
+#ifndef __has_feature
+# define __has_feature(x) 0
+#endif
+
+#ifndef __has_extension
+# define __has_extension(x) 0
+#endif
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0
+#endif
+
+#ifndef __has_builtin
+# define __has_builtin(x) 0
+#endif
+
+// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
+// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
+#ifndef LLVM_HAS_CPP_ATTRIBUTE
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+# define LLVM_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+#endif
+
+/// \macro LLVM_GNUC_PREREQ
+/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
+/// available.
+#ifndef LLVM_GNUC_PREREQ
+# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#  define LLVM_GNUC_PREREQ(maj, min, patch) \
+    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
+     ((maj) << 20) + ((min) << 10) + (patch))
+# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
+#  define LLVM_GNUC_PREREQ(maj, min, patch) \
+    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
+# else
+#  define LLVM_GNUC_PREREQ(maj, min, patch) 0
+# endif
+#endif
+
+/// \macro LLVM_MSC_PREREQ
+/// Is the compiler MSVC of at least the specified version?
+/// The common \param version values to check for are:
+/// * 1910: VS2017, version 15.1 & 15.2
+/// * 1911: VS2017, version 15.3 & 15.4
+/// * 1912: VS2017, version 15.5
+/// * 1913: VS2017, version 15.6
+/// * 1914: VS2017, version 15.7
+/// * 1915: VS2017, version 15.8
+/// * 1916: VS2017, version 15.9
+/// * 1920: VS2019, version 16.0
+/// * 1921: VS2019, version 16.1
+/// * 1922: VS2019, version 16.2
+/// * 1923: VS2019, version 16.3
+/// * 1924: VS2019, version 16.4
+/// * 1925: VS2019, version 16.5
+/// * 1926: VS2019, version 16.6
+/// * 1927: VS2019, version 16.7
+/// * 1928: VS2019, version 16.8 + 16.9
+/// * 1929: VS2019, version 16.10 + 16.11
+/// * 1930: VS2022, version 17.0
+#ifndef LLVM_MSC_PREREQ
+#ifdef _MSC_VER
+#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
+
+// We require at least VS 2019.
+#if !defined(LLVM_FORCE_USE_OLD_TOOLCHAIN)
+#if !LLVM_MSC_PREREQ(1920)
+#error LLVM requires at least VS 2019.
+#endif
+#endif
+
+#else
+#define LLVM_MSC_PREREQ(version) 0
+#endif
+#endif
+
+/// Does the compiler support ref-qualifiers for *this?
+///
+/// Sadly, this is separate from just rvalue reference support because GCC
+/// and MSVC implemented this later than everything else. This appears to be
+/// corrected in MSVC 2019 but not MSVC 2017.
+/// FIXME: Remove LLVM_HAS_RVALUE_REFERENCE_THIS macro
+#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
+
+/// Expands to '&' if ref-qualifiers for *this are supported.
+///
+/// This can be used to provide lvalue/rvalue overrides of member functions.
+/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
+#ifndef LLVM_LVALUE_FUNCTION
+#if LLVM_HAS_RVALUE_REFERENCE_THIS
+#define LLVM_LVALUE_FUNCTION &
+#else
+#define LLVM_LVALUE_FUNCTION
+#endif
+#endif
+
+/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
+/// into a shared library, then the class should be private to the library and
+/// not accessible from outside it.  Can also be used to mark variables and
+/// functions, making them private to any shared library they are linked into.
+/// On PE/COFF targets, library visibility is the default, so this isn't needed.
+///
+/// LLVM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with
+/// this attribute will be made public and visible outside of any shared library
+/// they are linked in to.
+#if __has_attribute(visibility) && !defined(__MINGW32__) &&                    \
+    !defined(__CYGWIN__) && !defined(_WIN32)
+#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
+#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
+#define LLVM_EXTERNAL_VISIBILITY __attribute__((visibility("default")))
+#else
+#define LLVM_EXTERNAL_VISIBILITY
+#endif
+#else
+#define LLVM_LIBRARY_VISIBILITY
+#define LLVM_EXTERNAL_VISIBILITY
+#endif
+
+#ifndef LLVM_PREFETCH
+#if defined(__GNUC__)
+#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
+#else
+#define LLVM_PREFETCH(addr, rw, locality)
+#endif
+#endif
+
+#ifndef LLVM_ATTRIBUTE_USED
+#if __has_attribute(used)
+#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
+#else
+#define LLVM_ATTRIBUTE_USED
+#endif
+#endif
+
+/// LLVM_NODISCARD - Warn if a type or return value is discarded.
+
+// Use the 'nodiscard' attribute in C++17 or newer mode.
+#ifndef LLVM_NODISCARD
+#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
+#define LLVM_NODISCARD [[nodiscard]]
+#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
+#define LLVM_NODISCARD [[clang::warn_unused_result]]
+// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also
+// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518).
+// Use the 'nodiscard' attribute in C++14 mode only with GCC.
+// TODO: remove this workaround when PR33518 is resolved.
+#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
+#define LLVM_NODISCARD [[nodiscard]]
+#else
+#define LLVM_NODISCARD
+#endif
+#endif
+
+// Indicate that a non-static, non-const C++ member function reinitializes
+// the entire object to a known state, independent of the previous state of
+// the object.
+//
+// The clang-tidy check bugprone-use-after-move recognizes this attribute as a
+// marker that a moved-from object has left the indeterminate state and can be
+// reused.
+#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
+#define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+#else
+#define LLVM_ATTRIBUTE_REINITIALIZES
+#endif
+
+// Some compilers warn about unused functions. When a function is sometimes
+// used or not depending on build settings (e.g. a function only called from
+// within "assert"), this attribute can be used to suppress such warnings.
+//
+// However, it shouldn't be used for unused *variables*, as those have a much
+// more portable solution:
+//   (void)unused_var_name;
+// Prefer cast-to-void wherever it is sufficient.
+#ifndef LLVM_ATTRIBUTE_UNUSED
+#if __has_attribute(unused)
+#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#else
+#define LLVM_ATTRIBUTE_UNUSED
+#endif
+#endif
+
+// FIXME: Provide this for PE/COFF targets.
+#if __has_attribute(weak) && !defined(__MINGW32__) && !defined(__CYGWIN__) &&  \
+    !defined(_WIN32)
+#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
+#else
+#define LLVM_ATTRIBUTE_WEAK
+#endif
+
+#ifndef LLVM_READNONE
+// Prior to clang 3.2, clang did not accept any spelling of
+// __has_attribute(const), so assume it is supported.
+#if defined(__clang__) || defined(__GNUC__)
+// aka 'CONST' but following LLVM Conventions.
+#define LLVM_READNONE __attribute__((__const__))
+#else
+#define LLVM_READNONE
+#endif
+#endif
+
+#ifndef LLVM_READONLY
+#if __has_attribute(pure) || defined(__GNUC__)
+// aka 'PURE' but following LLVM Conventions.
+#define LLVM_READONLY __attribute__((__pure__))
+#else
+#define LLVM_READONLY
+#endif
+#endif
+
+#if __has_attribute(minsize)
+#define LLVM_ATTRIBUTE_MINSIZE __attribute__((minsize))
+#else
+#define LLVM_ATTRIBUTE_MINSIZE
+#endif
+
+#ifndef LLVM_LIKELY
+#if __has_builtin(__builtin_expect) || defined(__GNUC__)
+#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
+#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
+#else
+#define LLVM_LIKELY(EXPR) (EXPR)
+#define LLVM_UNLIKELY(EXPR) (EXPR)
+#endif
+#endif
+
+/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
+/// mark a method "not for inlining".
+#ifndef LLVM_ATTRIBUTE_NOINLINE
+#if __has_attribute(noinline)
+#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
+#else
+#define LLVM_ATTRIBUTE_NOINLINE
+#endif
+#endif
+
+/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
+/// so, mark a method "always inline" because it is performance sensitive.
+#ifndef LLVM_ATTRIBUTE_ALWAYS_INLINE
+#if __has_attribute(always_inline)
+#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
+#else
+#define LLVM_ATTRIBUTE_ALWAYS_INLINE inline
+#endif
+#endif
+
+/// LLVM_ATTRIBUTE_NO_DEBUG - On compilers where we have a directive to do
+/// so, mark a method "no debug" because debug info makes the debugger
+/// experience worse.
+#if __has_attribute(nodebug)
+#define LLVM_ATTRIBUTE_NODEBUG __attribute__((nodebug))
+#else
+#define LLVM_ATTRIBUTE_NODEBUG
+#endif
+
+#ifndef LLVM_ATTRIBUTE_RETURNS_NONNULL
+#if __has_attribute(returns_nonnull)
+#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#elif defined(_MSC_VER)
+#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
+#else
+#define LLVM_ATTRIBUTE_RETURNS_NONNULL
+#endif
+#endif
+
+/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
+/// pointer that does not alias any other valid pointer.
+#ifndef LLVM_ATTRIBUTE_RETURNS_NOALIAS
+#ifdef __GNUC__
+#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
+#elif defined(_MSC_VER)
+#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
+#else
+#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
+#endif
+#endif
+
+/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
+#ifndef LLVM_FALLTHROUGH
+#if defined(__cplusplus) && __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
+#define LLVM_FALLTHROUGH [[fallthrough]]
+#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
+#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
+#elif __has_attribute(fallthrough)
+#define LLVM_FALLTHROUGH __attribute__((fallthrough))
+#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
+#define LLVM_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define LLVM_FALLTHROUGH
+#endif
+#endif
+
+/// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
+/// they are constant initialized.
+#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#define LLVM_REQUIRE_CONSTANT_INITIALIZATION                                   \
+  [[clang::require_constant_initialization]]
+#else
+#define LLVM_REQUIRE_CONSTANT_INITIALIZATION
+#endif
+
+/// LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable
+/// lifetime warnings.
+#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Owner)
+#define LLVM_GSL_OWNER [[gsl::Owner]]
+#else
+#define LLVM_GSL_OWNER
+#endif
+
+/// LLVM_GSL_POINTER - Apply this to non-owning classes like
+/// std::string_view to enable lifetime warnings.
+#if LLVM_HAS_CPP_ATTRIBUTE(gsl::Pointer)
+#define LLVM_GSL_POINTER [[gsl::Pointer]]
+#else
+#define LLVM_GSL_POINTER
+#endif
+
+/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
+/// pedantic diagnostics.
+#ifndef LLVM_EXTENSION
+#ifdef __GNUC__
+#define LLVM_EXTENSION __extension__
+#else
+#define LLVM_EXTENSION
+#endif
+#endif
+
+// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
+// This macro will be removed.
+// Use C++14's attribute instead: [[deprecated("message")]]
+#ifndef LLVM_ATTRIBUTE_DEPRECATED
+#define LLVM_ATTRIBUTE_DEPRECATED(decl, message) [[deprecated(message)]] decl
+#endif
+
+/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
+/// to an expression which states that it is undefined behavior for the
+/// compiler to reach this point.  Otherwise is not defined.
+#ifndef LLVM_BUILTIN_UNREACHABLE
+#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
+# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+# define LLVM_BUILTIN_UNREACHABLE __assume(false)
+#else
+# define LLVM_BUILTIN_UNREACHABLE
+#endif
+#endif
+
+/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
+/// which causes the program to exit abnormally.
+#ifndef LLVM_BUILTIN_TRAP
+#if __has_builtin(__builtin_trap) || defined(__GNUC__)
+# define LLVM_BUILTIN_TRAP __builtin_trap()
+#elif defined(_MSC_VER)
+// The __debugbreak intrinsic is supported by MSVC, does not require forward
+// declarations involving platform-specific typedefs (unlike RaiseException),
+// results in a call to vectored exception handlers, and encodes to a short
+// instruction that still causes the trapping behavior we want.
+# define LLVM_BUILTIN_TRAP __debugbreak()
+#else
+# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
+#endif
+#endif
+
+/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
+/// an expression which causes the program to break while running
+/// under a debugger.
+#ifndef LLVM_BUILTIN_DEBUGTRAP
+#if __has_builtin(__builtin_debugtrap)
+# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
+#elif defined(_MSC_VER)
+// The __debugbreak intrinsic is supported by MSVC and breaks while
+// running under the debugger, and also supports invoking a debugger
+// when the OS is configured appropriately.
+# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
+#else
+// Just continue execution when built with compilers that have no
+// support. This is a debugging aid and not intended to force the
+// program to abort if encountered.
+# define LLVM_BUILTIN_DEBUGTRAP
+#endif
+#endif
+
+/// \macro LLVM_ASSUME_ALIGNED
+/// Returns a pointer with an assumed alignment.
+#ifndef LLVM_ASSUME_ALIGNED
+#if __has_builtin(__builtin_assume_aligned) || defined(__GNUC__)
+# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
+#elif defined(LLVM_BUILTIN_UNREACHABLE)
+# define LLVM_ASSUME_ALIGNED(p, a) \
+           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
+#else
+# define LLVM_ASSUME_ALIGNED(p, a) (p)
+#endif
+#endif
+
+/// \macro LLVM_PACKED
+/// Used to specify a packed structure.
+/// LLVM_PACKED(
+///    struct A {
+///      int i;
+///      int j;
+///      int k;
+///      long long l;
+///   });
+///
+/// LLVM_PACKED_START
+/// struct B {
+///   int i;
+///   int j;
+///   int k;
+///   long long l;
+/// };
+/// LLVM_PACKED_END
+#ifndef LLVM_PACKED
+#ifdef _MSC_VER
+# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
+# define LLVM_PACKED_START __pragma(pack(push, 1))
+# define LLVM_PACKED_END   __pragma(pack(pop))
+#else
+# define LLVM_PACKED(d) d __attribute__((packed))
+# define LLVM_PACKED_START _Pragma("pack(push, 1)")
+# define LLVM_PACKED_END   _Pragma("pack(pop)")
+#endif
+#endif
+
+/// \macro LLVM_PTR_SIZE
+/// A constant integer equivalent to the value of sizeof(void*).
+/// Generally used in combination with alignas or when doing computation in the
+/// preprocessor.
+#ifndef LLVM_PTR_SIZE
+#ifdef __SIZEOF_POINTER__
+# define LLVM_PTR_SIZE __SIZEOF_POINTER__
+#elif defined(_WIN64)
+# define LLVM_PTR_SIZE 8
+#elif defined(_WIN32)
+# define LLVM_PTR_SIZE 4
+#elif defined(_MSC_VER)
+# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
+#else
+# define LLVM_PTR_SIZE sizeof(void *)
+#endif
+#endif
+
+/// \macro LLVM_MEMORY_SANITIZER_BUILD
+/// Whether LLVM itself is built with MemorySanitizer instrumentation.
+#if __has_feature(memory_sanitizer)
+# define LLVM_MEMORY_SANITIZER_BUILD 1
+# include <sanitizer/msan_interface.h>
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE __attribute__((no_sanitize_memory))
+#else
+# define LLVM_MEMORY_SANITIZER_BUILD 0
+# define __msan_allocated_memory(p, size)
+# define __msan_unpoison(p, size)
+# define LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE
+#endif
+
+/// \macro LLVM_ADDRESS_SANITIZER_BUILD
+/// Whether LLVM itself is built with AddressSanitizer instrumentation.
+#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
+# define LLVM_ADDRESS_SANITIZER_BUILD 1
+# include <sanitizer/asan_interface.h>
+#else
+# define LLVM_ADDRESS_SANITIZER_BUILD 0
+# define __asan_poison_memory_region(p, size)
+# define __asan_unpoison_memory_region(p, size)
+#endif
+
+/// \macro LLVM_THREAD_SANITIZER_BUILD
+/// Whether LLVM itself is built with ThreadSanitizer instrumentation.
+#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
+# define LLVM_THREAD_SANITIZER_BUILD 1
+#else
+# define LLVM_THREAD_SANITIZER_BUILD 0
+#endif
+
+#if LLVM_THREAD_SANITIZER_BUILD
+// Thread Sanitizer is a tool that finds races in code.
+// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
+// tsan detects these exact functions by name.
+#ifdef __cplusplus
+extern "C" {
+#endif
+void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
+void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
+void AnnotateIgnoreWritesBegin(const char *file, int line);
+void AnnotateIgnoreWritesEnd(const char *file, int line);
+#ifdef __cplusplus
+}
+#endif
+
+// This marker is used to define a happens-before arc. The race detector will
+// infer an arc from the begin to the end when they share the same pointer
+// argument.
+# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
+
+// This marker defines the destination of a happens-before arc.
+# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
+
+// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
+# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+
+// Resume checking for racy writes.
+# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
+#else
+# define TsanHappensBefore(cv)
+# define TsanHappensAfter(cv)
+# define TsanIgnoreWritesBegin()
+# define TsanIgnoreWritesEnd()
+#endif
+
+/// \macro LLVM_NO_SANITIZE
+/// Disable a particular sanitizer for a function.
+#ifndef LLVM_NO_SANITIZE
+#if __has_attribute(no_sanitize)
+#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
+#else
+#define LLVM_NO_SANITIZE(KIND)
+#endif
+#endif
+
+/// Mark debug helper function definitions like dump() that should not be
+/// stripped from debug builds.
+/// Note that you should also surround dump() functions with
+/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
+/// get stripped in release builds.
+// FIXME: Move this to a private config.h as it's not usable in public headers.
+#ifndef LLVM_DUMP_METHOD
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
+#else
+#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
+#endif
+#endif
+
+/// \macro LLVM_PRETTY_FUNCTION
+/// Gets a user-friendly looking function signature for the current scope
+/// using the best available method on each platform.  The exact format of the
+/// resulting string is implementation specific and non-portable, so this should
+/// only be used, for example, for logging or diagnostics.
+#ifndef LLVM_PRETTY_FUNCTION
+#if defined(_MSC_VER)
+#define LLVM_PRETTY_FUNCTION __FUNCSIG__
+#elif defined(__GNUC__) || defined(__clang__)
+#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#else
+#define LLVM_PRETTY_FUNCTION __func__
+#endif
+#endif
+
+/// \macro LLVM_THREAD_LOCAL
+/// A thread-local storage specifier which can be used with globals,
+/// extern globals, and static globals.
+///
+/// This is essentially an extremely restricted analog to C++11's thread_local
+/// support. It uses thread_local if available, falling back on gcc __thread
+/// if not. __thread doesn't support many of the C++11 thread_local's
+/// features. You should only use this for PODs that you can statically
+/// initialize to some constant value. In almost all circumstances this is most
+/// appropriate for use with a pointer, integer, or small aggregation of
+/// pointers and integers.
+#if __has_feature(cxx_thread_local) || defined(_MSC_VER)
+#define LLVM_THREAD_LOCAL thread_local
+#else
+// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
+// we only need the restricted functionality that provides.
+#define LLVM_THREAD_LOCAL __thread
+#endif
+
+/// \macro LLVM_ENABLE_EXCEPTIONS
+/// Whether LLVM is built with exception support.
+#if __has_feature(cxx_exceptions)
+#define LLVM_ENABLE_EXCEPTIONS 1
+#elif defined(__GNUC__) && defined(__EXCEPTIONS)
+#define LLVM_ENABLE_EXCEPTIONS 1
+#elif defined(_MSC_VER) && defined(_CPPUNWIND)
+#define LLVM_ENABLE_EXCEPTIONS 1
+#endif
+
+/// \macro LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
+/// Disable the profile instrument for a function.
+#if __has_attribute(no_profile_instrument_function)
+#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION                                    \
+  __attribute__((no_profile_instrument_function))
+#else
+#define LLVM_NO_PROFILE_INSTRUMENT_FUNCTION
+#endif
+
+#endif
diff --git a/wpiutil/src/main/native/include/wpi/ConvertUTF.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ConvertUTF.h
similarity index 79%
rename from wpiutil/src/main/native/include/wpi/ConvertUTF.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/ConvertUTF.h
index aa113b1..436bc6d 100644
--- a/wpiutil/src/main/native/include/wpi/ConvertUTF.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ConvertUTF.h
@@ -1,9 +1,8 @@
 /*===--- ConvertUTF.h - Universal Character Names conversions ---------------===
  *
- *                     The LLVM Compiler Infrastructure
- *
- * This file is distributed under the University of Illinois Open Source
- * License. See LICENSE.TXT for details.
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *==------------------------------------------------------------------------==*/
 /*
@@ -87,24 +86,21 @@
 
 ------------------------------------------------------------------------ */
 
-#ifndef LLVM_SUPPORT_CONVERTUTF_H
-#define LLVM_SUPPORT_CONVERTUTF_H
+#ifndef WPIUTIL_WPI_CONVERTUTF_H
+#define WPIUTIL_WPI_CONVERTUTF_H
 
-#include "wpi/span.h"
+#include <span>
 
 #include <cstddef>
 #include <string>
 #include <string_view>
 #include <system_error>
 
-// Wrap everything in namespace wpi so that programs can link with wpiutil and
+// Wrap everything in namespace wpi so that programs can link with llvm and
 // their own version of the unicode libraries.
 
 namespace wpi {
 
-template <typename T>
-class SmallVectorImpl;
-
 /* ---------------------------------------------------------------------
     The following 4 definitions are compiler-specific.
     The C standard does not guarantee that wchar_t has at least
@@ -187,6 +183,38 @@
 /*************************************************************************/
 /* Below are LLVM-specific wrappers of the functions above. */
 
+template <typename T> class SmallVectorImpl;
+
+/**
+ * Convert an UTF8 string_view to UTF8, UTF16, or UTF32 depending on
+ * WideCharWidth. The converted data is written to ResultPtr, which needs to
+ * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success,
+ * ResultPtr will point one after the end of the copied string. On failure,
+ * ResultPtr will not be changed, and ErrorPtr will be set to the location of
+ * the first character which could not be converted.
+ * \return true on success.
+ */
+bool ConvertUTF8toWide(unsigned WideCharWidth, std::string_view Source,
+                       char *&ResultPtr, const UTF8 *&ErrorPtr);
+
+/**
+* Converts a UTF-8 string_view to a std::wstring.
+* \return true on success.
+*/
+bool ConvertUTF8toWide(std::string_view Source, std::wstring &Result);
+
+/**
+* Converts a UTF-8 C-string to a std::wstring.
+* \return true on success.
+*/
+bool ConvertUTF8toWide(const char *Source, std::wstring &Result);
+
+/**
+* Converts a std::wstring to a UTF-8 encoded std::string.
+* \return true on success.
+*/
+bool convertWideToUTF8(const std::wstring &Source, SmallVectorImpl<char> &Result);
+
 
 /**
  * Convert an Unicode code point to UTF8 sequence.
@@ -215,10 +243,10 @@
  *
  * \sa ConvertUTF8toUTF32
  */
-static inline ConversionResult convertUTF8Sequence(const UTF8 **source,
-                                                   const UTF8 *sourceEnd,
-                                                   UTF32 *target,
-                                                   ConversionFlags flags) {
+inline ConversionResult convertUTF8Sequence(const UTF8 **source,
+                                            const UTF8 *sourceEnd,
+                                            UTF32 *target,
+                                            ConversionFlags flags) {
   if (*source == sourceEnd)
     return sourceExhausted;
   unsigned size = getNumBytesForUTF8(**source);
@@ -231,15 +259,25 @@
  * Returns true if a blob of text starts with a UTF-16 big or little endian byte
  * order mark.
  */
-bool hasUTF16ByteOrderMark(span<const char> SrcBytes);
+bool hasUTF16ByteOrderMark(std::span<const char> SrcBytes);
 
 /**
- * Converts a UTF-16 string into a UTF-8 string.
+ * Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.
  *
+ * \param [in] SrcBytes A buffer of what is assumed to be UTF-16 encoded text.
+ * \param [out] Out Converted UTF-8 is stored here on success.
  * \returns true on success
  */
-bool convertUTF16ToUTF8String(span<const UTF16> SrcUTF16,
-                              SmallVectorImpl<char> &DstUTF8);
+bool convertUTF16ToUTF8String(std::span<const char> SrcBytes, SmallVectorImpl<char> &Out);
+
+/**
+* Converts a UTF16 string into a UTF8 std::string.
+*
+* \param [in] Src A buffer of UTF-16 encoded text.
+* \param [out] Out Converted UTF-8 is stored here on success.
+* \returns true on success
+*/
+bool convertUTF16ToUTF8String(std::span<const UTF16> Src, SmallVectorImpl<char> &Out);
 
 /**
  * Converts a UTF-8 string into a UTF-16 string with native endianness.
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DJB.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DJB.h
new file mode 100644
index 0000000..2615bba
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DJB.h
@@ -0,0 +1,29 @@
+//===-- llvm/Support/DJB.h ---DJB Hash --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains support for the DJ Bernstein hash function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_DJB_H
+#define WPIUTIL_WPI_DJB_H
+
+#include <string_view>
+
+namespace wpi {
+
+/// The Bernstein hash function used by the DWARF accelerator tables.
+inline uint32_t djbHash(std::string_view Buffer, uint32_t H = 5381) {
+  for (unsigned char C : Buffer)
+    H = (H << 5) + H + C;
+  return H;
+}
+
+} // namespace wpi
+
+#endif // WPIUTIL_WPI_DJB_H
diff --git a/wpiutil/src/main/native/include/wpi/DenseMap.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMap.h
similarity index 83%
rename from wpiutil/src/main/native/include/wpi/DenseMap.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMap.h
index 12bb712..b1ffd43 100644
--- a/wpiutil/src/main/native/include/wpi/DenseMap.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMap.h
@@ -1,14 +1,14 @@
 //===- llvm/ADT/DenseMap.h - Dense probed hash table ------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the DenseMap class.
-//
+///
+/// \file
+/// This file defines the DenseMap class.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_DENSEMAP_H
@@ -19,12 +19,14 @@
 #include "wpi/AlignOf.h"
 #include "wpi/Compiler.h"
 #include "wpi/MathExtras.h"
-#include "wpi/PointerLikeTypeTraits.h"
+#include "wpi/MemAlloc.h"
+#include "wpi/ReverseIteration.h"
 #include "wpi/type_traits.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
+#include <initializer_list>
 #include <iterator>
 #include <new>
 #include <type_traits>
@@ -38,6 +40,8 @@
 // implementation without requiring two members.
 template <typename KeyT, typename ValueT>
 struct DenseMapPair : public std::pair<KeyT, ValueT> {
+  using std::pair<KeyT, ValueT>::pair;
+
   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
   const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
@@ -73,6 +77,8 @@
     // empty buckets.
     if (empty())
       return end();
+    if (shouldReverseIterate<KeyT>())
+      return makeIterator(getBucketsEnd() - 1, getBuckets(), *this);
     return makeIterator(getBuckets(), getBucketsEnd(), *this);
   }
   inline iterator end() {
@@ -81,6 +87,8 @@
   inline const_iterator begin() const {
     if (empty())
       return end();
+    if (shouldReverseIterate<KeyT>())
+      return makeConstIterator(getBucketsEnd() - 1, getBuckets(), *this);
     return makeConstIterator(getBuckets(), getBucketsEnd(), *this);
   }
   inline const_iterator end() const {
@@ -113,8 +121,8 @@
     }
 
     const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
-    if (isPodLike<KeyT>::value && isPodLike<ValueT>::value) {
-      // Use a simpler loop when these are trivial types.
+    if (std::is_trivially_destructible<ValueT>::value) {
+      // Use a simpler loop when values don't need destruction.
       for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
         P->getFirst() = EmptyKey;
     } else {
@@ -143,13 +151,19 @@
   iterator find(const_arg_type_t<KeyT> Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeIterator(TheBucket,
+                          shouldReverseIterate<KeyT>() ? getBuckets()
+                                                       : getBucketsEnd(),
+                          *this, true);
     return end();
   }
   const_iterator find(const_arg_type_t<KeyT> Val) const {
     const BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeConstIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeConstIterator(TheBucket,
+                               shouldReverseIterate<KeyT>() ? getBuckets()
+                                                            : getBucketsEnd(),
+                               *this, true);
     return end();
   }
 
@@ -162,14 +176,20 @@
   iterator find_as(const LookupKeyT &Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeIterator(TheBucket,
+                          shouldReverseIterate<KeyT>() ? getBuckets()
+                                                       : getBucketsEnd(),
+                          *this, true);
     return end();
   }
   template<class LookupKeyT>
   const_iterator find_as(const LookupKeyT &Val) const {
     const BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return makeConstIterator(TheBucket, getBucketsEnd(), *this, true);
+      return makeConstIterator(TheBucket,
+                               shouldReverseIterate<KeyT>() ? getBuckets()
+                                                            : getBucketsEnd(),
+                               *this, true);
     return end();
   }
 
@@ -203,16 +223,22 @@
   std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
     BucketT *TheBucket;
     if (LookupBucketFor(Key, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket =
         InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   // Inserts key,value pair into the map if the key isn't already in the map.
@@ -222,15 +248,21 @@
   std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
     BucketT *TheBucket;
     if (LookupBucketFor(Key, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   /// Alternate version of insert() which allows a different, and possibly
@@ -243,16 +275,22 @@
                                       const LookupKeyT &Val) {
     BucketT *TheBucket;
     if (LookupBucketFor(Val, TheBucket))
-      return std::make_pair(
-               makeIterator(TheBucket, getBucketsEnd(), *this, true),
-               false); // Already in map.
+      return std::make_pair(makeIterator(TheBucket,
+                                         shouldReverseIterate<KeyT>()
+                                             ? getBuckets()
+                                             : getBucketsEnd(),
+                                         *this, true),
+                            false); // Already in map.
 
     // Otherwise, insert the new element.
     TheBucket = InsertIntoBucketWithLookup(TheBucket, std::move(KV.first),
                                            std::move(KV.second), Val);
-    return std::make_pair(
-             makeIterator(TheBucket, getBucketsEnd(), *this, true),
-             true);
+    return std::make_pair(makeIterator(TheBucket,
+                                       shouldReverseIterate<KeyT>()
+                                           ? getBuckets()
+                                           : getBucketsEnd(),
+                                       *this, true),
+                          true);
   }
 
   /// insert - Range insertion of pairs.
@@ -389,7 +427,8 @@
     setNumEntries(other.getNumEntries());
     setNumTombstones(other.getNumTombstones());
 
-    if (isPodLike<KeyT>::value && isPodLike<ValueT>::value)
+    if (std::is_trivially_copyable<KeyT>::value &&
+        std::is_trivially_copyable<ValueT>::value)
       memcpy(reinterpret_cast<void *>(getBuckets()), other.getBuckets(),
              getNumBuckets() * sizeof(BucketT));
     else
@@ -426,12 +465,20 @@
   iterator makeIterator(BucketT *P, BucketT *E,
                         DebugEpochBase &Epoch,
                         bool NoAdvance=false) {
+    if (shouldReverseIterate<KeyT>()) {
+      BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
+      return iterator(B, E, Epoch, NoAdvance);
+    }
     return iterator(P, E, Epoch, NoAdvance);
   }
 
   const_iterator makeConstIterator(const BucketT *P, const BucketT *E,
                                    const DebugEpochBase &Epoch,
                                    const bool NoAdvance=false) const {
+    if (shouldReverseIterate<KeyT>()) {
+      const BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
+      return const_iterator(B, E, Epoch, NoAdvance);
+    }
     return const_iterator(P, E, Epoch, NoAdvance);
   }
 
@@ -679,7 +726,7 @@
   unsigned NumBuckets;
 
 public:
-  /// Create a DenseMap wth an optional \p InitialReserve that guarantee that
+  /// Create a DenseMap with an optional \p InitialReserve that guarantee that
   /// this number of elements can be inserted in the map without grow()
   explicit DenseMap(unsigned InitialReserve = 0) { init(InitialReserve); }
 
@@ -706,7 +753,7 @@
 
   ~DenseMap() {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
   }
 
   void swap(DenseMap& RHS) {
@@ -726,7 +773,7 @@
 
   DenseMap& operator=(DenseMap &&other) {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
     init(0);
     swap(other);
     return *this;
@@ -734,7 +781,7 @@
 
   void copyFrom(const DenseMap& other) {
     this->destroyAll();
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
     if (allocateBuckets(other.NumBuckets)) {
       this->BaseT::copyFrom(other);
     } else {
@@ -767,10 +814,12 @@
     this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
 
     // Free the old table.
-    operator delete(OldBuckets);
+    deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
+                      alignof(BucketT));
   }
 
   void shrink_and_clear() {
+    unsigned OldNumBuckets = NumBuckets;
     unsigned OldNumEntries = NumEntries;
     this->destroyAll();
 
@@ -783,7 +832,8 @@
       return;
     }
 
-    operator delete(Buckets);
+    deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
+                      alignof(BucketT));
     init(NewNumBuckets);
   }
 
@@ -819,7 +869,8 @@
       return false;
     }
 
-    Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT) * NumBuckets));
+    Buckets = static_cast<BucketT *>(
+        allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
     return true;
   }
 };
@@ -874,6 +925,9 @@
     this->insert(I, E);
   }
 
+  SmallDenseMap(std::initializer_list<typename BaseT::value_type> Vals)
+      : SmallDenseMap(Vals.begin(), Vals.end()) {}
+
   ~SmallDenseMap() {
     this->destroyAll();
     deallocateBuckets();
@@ -904,7 +958,7 @@
           std::swap(*LHSB, *RHSB);
           continue;
         }
-        // Swap separately and handle any assymetry.
+        // Swap separately and handle any asymmetry.
         std::swap(LHSB->getFirst(), RHSB->getFirst());
         if (hasLHSValue) {
           ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
@@ -986,16 +1040,13 @@
   }
 
   void grow(unsigned AtLeast) {
-    if (AtLeast >= InlineBuckets)
+    if (AtLeast > InlineBuckets)
       AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
 
     if (Small) {
-      if (AtLeast < InlineBuckets)
-        return; // Nothing to do.
-
       // First move the inline buckets into a temporary storage.
       AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
-      BucketT *TmpBegin = reinterpret_cast<BucketT *>(TmpStorage.buffer);
+      BucketT *TmpBegin = reinterpret_cast<BucketT *>(&TmpStorage);
       BucketT *TmpEnd = TmpBegin;
 
       // Loop over the buckets, moving non-empty, non-tombstones into the
@@ -1015,10 +1066,13 @@
         P->getFirst().~KeyT();
       }
 
-      // Now make this map use the large rep, and move all the entries back
-      // into it.
-      Small = false;
-      new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
+      // AtLeast == InlineBuckets can happen if there are many tombstones,
+      // and grow() is used to remove them. Usually we always switch to the
+      // large rep here.
+      if (AtLeast > InlineBuckets) {
+        Small = false;
+        new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
+      }
       this->moveFromOldBuckets(TmpBegin, TmpEnd);
       return;
     }
@@ -1034,7 +1088,8 @@
     this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);
 
     // Free the old table.
-    operator delete(OldRep.Buckets);
+    deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
+                      alignof(BucketT));
   }
 
   void shrink_and_clear() {
@@ -1081,8 +1136,8 @@
     assert(Small);
     // Note that this cast does not violate aliasing rules as we assert that
     // the memory's dynamic type is the small, inline bucket buffer, and the
-    // 'storage.buffer' static type is 'char *'.
-    return reinterpret_cast<const BucketT *>(storage.buffer);
+    // 'storage' is a POD containing a char buffer.
+    return reinterpret_cast<const BucketT *>(&storage);
   }
 
   BucketT *getInlineBuckets() {
@@ -1093,7 +1148,7 @@
   const LargeRep *getLargeRep() const {
     assert(!Small);
     // Note, same rule about aliasing as with getInlineBuckets.
-    return reinterpret_cast<const LargeRep *>(storage.buffer);
+    return reinterpret_cast<const LargeRep *>(&storage);
   }
 
   LargeRep *getLargeRep() {
@@ -1118,15 +1173,17 @@
     if (Small)
       return;
 
-    operator delete(getLargeRep()->Buckets);
+    deallocate_buffer(getLargeRep()->Buckets,
+                      sizeof(BucketT) * getLargeRep()->NumBuckets,
+                      alignof(BucketT));
     getLargeRep()->~LargeRep();
   }
 
   LargeRep allocateBuckets(unsigned Num) {
     assert(Num > InlineBuckets && "Must allocate more buckets than are inline");
-    LargeRep Rep = {
-      static_cast<BucketT*>(operator new(sizeof(BucketT) * Num)), Num
-    };
+    LargeRep Rep = {static_cast<BucketT *>(allocate_buffer(
+                        sizeof(BucketT) * Num, alignof(BucketT))),
+                    Num};
     return Rep;
   }
 };
@@ -1137,8 +1194,6 @@
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
   friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
 
-  using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
-
 public:
   using difference_type = ptrdiff_t;
   using value_type =
@@ -1160,6 +1215,10 @@
     assert(isHandleInSync() && "invalid construction!");
 
     if (NoAdvance) return;
+    if (shouldReverseIterate<KeyT>()) {
+      RetreatPastEmptyBuckets();
+      return;
+    }
     AdvancePastEmptyBuckets();
   }
 
@@ -1167,37 +1226,48 @@
   // for const iterator destinations so it doesn't end up as a user defined copy
   // constructor.
   template <bool IsConstSrc,
-            typename = typename std::enable_if<!IsConstSrc && IsConst>::type>
+            typename = std::enable_if_t<!IsConstSrc && IsConst>>
   DenseMapIterator(
       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
       : DebugEpochBase::HandleBase(I), Ptr(I.Ptr), End(I.End) {}
 
   reference operator*() const {
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "dereferencing end() iterator");
+    if (shouldReverseIterate<KeyT>())
+      return Ptr[-1];
     return *Ptr;
   }
   pointer operator->() const {
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "dereferencing end() iterator");
+    if (shouldReverseIterate<KeyT>())
+      return &(Ptr[-1]);
     return Ptr;
   }
 
-  bool operator==(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
+  friend bool operator==(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    assert((!LHS.Ptr || LHS.isHandleInSync()) && "handle not in sync!");
     assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
+    assert(LHS.getEpochAddress() == RHS.getEpochAddress() &&
            "comparing incomparable iterators!");
-    return Ptr == RHS.Ptr;
+    return LHS.Ptr == RHS.Ptr;
   }
-  bool operator!=(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
-    assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
-           "comparing incomparable iterators!");
-    return Ptr != RHS.Ptr;
+
+  friend bool operator!=(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    return !(LHS == RHS);
   }
 
   inline DenseMapIterator& operator++() {  // Preincrement
     assert(isHandleInSync() && "invalid iterator access!");
+    assert(Ptr != End && "incrementing end() iterator");
+    if (shouldReverseIterate<KeyT>()) {
+      --Ptr;
+      RetreatPastEmptyBuckets();
+      return *this;
+    }
     ++Ptr;
     AdvancePastEmptyBuckets();
     return *this;
@@ -1236,4 +1306,4 @@
 
 } // end namespace wpi
 
-#endif // LLVM_ADT_DENSEMAP_H
+#endif // WPIUTIL_WPI_DENSEMAP_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMapInfo.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMapInfo.h
new file mode 100644
index 0000000..0ff8fc9
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/DenseMapInfo.h
@@ -0,0 +1,293 @@
+//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines DenseMapInfo traits for DenseMap.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_DENSEMAPINFO_H
+#define WPIUTIL_WPI_DENSEMAPINFO_H
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <tuple>
+#include <utility>
+
+namespace wpi {
+
+namespace detail {
+
+/// Simplistic combination of 32-bit hash values into 32-bit hash values.
+static inline unsigned combineHashValue(unsigned a, unsigned b) {
+  uint64_t key = (uint64_t)a << 32 | (uint64_t)b;
+  key += ~(key << 32);
+  key ^= (key >> 22);
+  key += ~(key << 13);
+  key ^= (key >> 8);
+  key += (key << 3);
+  key ^= (key >> 15);
+  key += ~(key << 27);
+  key ^= (key >> 31);
+  return (unsigned)key;
+}
+
+} // end namespace detail
+
+/// An information struct used to provide DenseMap with the various necessary
+/// components for a given value type `T`. `Enable` is an optional additional
+/// parameter that is used to support SFINAE (generally using std::enable_if_t)
+/// in derived DenseMapInfo specializations; in non-SFINAE use cases this should
+/// just be `void`.
+template<typename T, typename Enable = void>
+struct DenseMapInfo {
+  //static inline T getEmptyKey();
+  //static inline T getTombstoneKey();
+  //static unsigned getHashValue(const T &Val);
+  //static bool isEqual(const T &LHS, const T &RHS);
+};
+
+// Provide DenseMapInfo for all pointers. Come up with sentinel pointer values
+// that are aligned to alignof(T) bytes, but try to avoid requiring T to be
+// complete. This allows clients to instantiate DenseMap<T*, ...> with forward
+// declared key types. Assume that no pointer key type requires more than 4096
+// bytes of alignment.
+template<typename T>
+struct DenseMapInfo<T*> {
+  // The following should hold, but it would require T to be complete:
+  // static_assert(alignof(T) <= (1 << Log2MaxAlign),
+  //               "DenseMap does not support pointer keys requiring more than "
+  //               "Log2MaxAlign bits of alignment");
+  static constexpr uintptr_t Log2MaxAlign = 12;
+
+  static inline T* getEmptyKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-1);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static inline T* getTombstoneKey() {
+    uintptr_t Val = static_cast<uintptr_t>(-2);
+    Val <<= Log2MaxAlign;
+    return reinterpret_cast<T*>(Val);
+  }
+
+  static unsigned getHashValue(const T *PtrVal) {
+    return (unsigned((uintptr_t)PtrVal) >> 4) ^
+           (unsigned((uintptr_t)PtrVal) >> 9);
+  }
+
+  static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for chars.
+template<> struct DenseMapInfo<char> {
+  static inline char getEmptyKey() { return ~0; }
+  static inline char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const char& Val) { return Val * 37U; }
+
+  static bool isEqual(const char &LHS, const char &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned chars.
+template <> struct DenseMapInfo<unsigned char> {
+  static inline unsigned char getEmptyKey() { return ~0; }
+  static inline unsigned char getTombstoneKey() { return ~0 - 1; }
+  static unsigned getHashValue(const unsigned char &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned char &LHS, const unsigned char &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned shorts.
+template <> struct DenseMapInfo<unsigned short> {
+  static inline unsigned short getEmptyKey() { return 0xFFFF; }
+  static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
+  static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned ints.
+template<> struct DenseMapInfo<unsigned> {
+  static inline unsigned getEmptyKey() { return ~0U; }
+  static inline unsigned getTombstoneKey() { return ~0U - 1; }
+  static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
+
+  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned longs.
+template<> struct DenseMapInfo<unsigned long> {
+  static inline unsigned long getEmptyKey() { return ~0UL; }
+  static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
+
+  static unsigned getHashValue(const unsigned long& Val) {
+    return (unsigned)(Val * 37UL);
+  }
+
+  static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for unsigned long longs.
+template<> struct DenseMapInfo<unsigned long long> {
+  static inline unsigned long long getEmptyKey() { return ~0ULL; }
+  static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
+
+  static unsigned getHashValue(const unsigned long long& Val) {
+    return (unsigned)(Val * 37ULL);
+  }
+
+  static bool isEqual(const unsigned long long& LHS,
+                      const unsigned long long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for shorts.
+template <> struct DenseMapInfo<short> {
+  static inline short getEmptyKey() { return 0x7FFF; }
+  static inline short getTombstoneKey() { return -0x7FFF - 1; }
+  static unsigned getHashValue(const short &Val) { return Val * 37U; }
+  static bool isEqual(const short &LHS, const short &RHS) { return LHS == RHS; }
+};
+
+// Provide DenseMapInfo for ints.
+template<> struct DenseMapInfo<int> {
+  static inline int getEmptyKey() { return 0x7fffffff; }
+  static inline int getTombstoneKey() { return -0x7fffffff - 1; }
+  static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
+
+  static bool isEqual(const int& LHS, const int& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for longs.
+template<> struct DenseMapInfo<long> {
+  static inline long getEmptyKey() {
+    return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
+  }
+
+  static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
+
+  static unsigned getHashValue(const long& Val) {
+    return (unsigned)(Val * 37UL);
+  }
+
+  static bool isEqual(const long& LHS, const long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for long longs.
+template<> struct DenseMapInfo<long long> {
+  static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
+  static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
+
+  static unsigned getHashValue(const long long& Val) {
+    return (unsigned)(Val * 37ULL);
+  }
+
+  static bool isEqual(const long long& LHS,
+                      const long long& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Provide DenseMapInfo for all pairs whose members have info.
+template<typename T, typename U>
+struct DenseMapInfo<std::pair<T, U>> {
+  using Pair = std::pair<T, U>;
+  using FirstInfo = DenseMapInfo<T>;
+  using SecondInfo = DenseMapInfo<U>;
+
+  static inline Pair getEmptyKey() {
+    return std::make_pair(FirstInfo::getEmptyKey(),
+                          SecondInfo::getEmptyKey());
+  }
+
+  static inline Pair getTombstoneKey() {
+    return std::make_pair(FirstInfo::getTombstoneKey(),
+                          SecondInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const Pair& PairVal) {
+    return detail::combineHashValue(FirstInfo::getHashValue(PairVal.first),
+                                    SecondInfo::getHashValue(PairVal.second));
+  }
+
+  static bool isEqual(const Pair &LHS, const Pair &RHS) {
+    return FirstInfo::isEqual(LHS.first, RHS.first) &&
+           SecondInfo::isEqual(LHS.second, RHS.second);
+  }
+};
+
+// Provide DenseMapInfo for all tuples whose members have info.
+template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+  using Tuple = std::tuple<Ts...>;
+
+  static inline Tuple getEmptyKey() {
+    return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
+  }
+
+  static inline Tuple getTombstoneKey() {
+    return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &values, std::false_type) {
+    using EltType = typename std::tuple_element<I, Tuple>::type;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return detail::combineHashValue(
+        DenseMapInfo<EltType>::getHashValue(std::get<I>(values)),
+        getHashValueImpl<I + 1>(values, atEnd));
+  }
+
+  template <unsigned I>
+  static unsigned getHashValueImpl(const Tuple &, std::true_type) {
+    return 0;
+  }
+
+  static unsigned getHashValue(const std::tuple<Ts...> &values) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return getHashValueImpl<0>(values, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &lhs, const Tuple &rhs, std::false_type) {
+    using EltType = typename std::tuple_element<I, Tuple>::type;
+    std::integral_constant<bool, I + 1 == sizeof...(Ts)> atEnd;
+    return DenseMapInfo<EltType>::isEqual(std::get<I>(lhs), std::get<I>(rhs)) &&
+           isEqualImpl<I + 1>(lhs, rhs, atEnd);
+  }
+
+  template <unsigned I>
+  static bool isEqualImpl(const Tuple &, const Tuple &, std::true_type) {
+    return true;
+  }
+
+  static bool isEqual(const Tuple &lhs, const Tuple &rhs) {
+    std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
+    return isEqualImpl<0>(lhs, rhs, atEnd);
+  }
+};
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_DENSEMAPINFO_H
diff --git a/wpiutil/src/main/native/include/wpi/Endian.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Endian.h
similarity index 85%
rename from wpiutil/src/main/native/include/wpi/Endian.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/Endian.h
index b31cb2d..d243a13 100644
--- a/wpiutil/src/main/native/include/wpi/Endian.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Endian.h
@@ -1,9 +1,8 @@
 //===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,14 +13,8 @@
 #ifndef WPIUTIL_WPI_ENDIAN_H
 #define WPIUTIL_WPI_ENDIAN_H
 
-#include "wpi/AlignOf.h"
 #include "wpi/Compiler.h"
 #include "wpi/SwapByteOrder.h"
-
-#if defined(__linux__) || defined(__GNU__)
-#include <endian.h>
-#endif
-
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -38,7 +31,7 @@
 
 namespace detail {
 
-// value is either alignment, or alignof(T) if alignment is 0.
+/// ::value is either alignment, or alignof(T) if alignment is 0.
 template<class T, int alignment>
 struct PickAlignment {
  enum { value = alignment == 0 ? alignof(T) : alignment };
@@ -49,13 +42,7 @@
 namespace endian {
 
 constexpr endianness system_endianness() {
-#ifdef _WIN32
-  return little;
-#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN
-  return big;
-#else
-  return little;
-#endif
+  return sys::IsBigEndianHost ? big : little;
 }
 
 template <typename value_type>
@@ -89,13 +76,7 @@
          endianness endian,
          std::size_t alignment>
 inline value_type read(const void *memory) {
-  value_type ret;
-
-  memcpy(&ret,
-         LLVM_ASSUME_ALIGNED(
-             memory, (detail::PickAlignment<value_type, alignment>::value)),
-         sizeof(value_type));
-  return byte_swap<value_type, endian>(ret);
+  return read<value_type, alignment>(memory, endian);
 }
 
 /// Read a value of a particular endianness from a buffer, and increment the
@@ -110,9 +91,7 @@
 template<typename value_type, endianness endian, std::size_t alignment,
          typename CharT>
 inline value_type readNext(const CharT *&memory) {
-  value_type ret = read<value_type, endian, alignment>(memory);
-  memory += sizeof(value_type);
-  return ret;
+  return readNext<value_type, alignment, CharT>(memory, endian);
 }
 
 /// Write a value to memory with a particular endianness.
@@ -128,12 +107,12 @@
          endianness endian,
          std::size_t alignment>
 inline void write(void *memory, value_type value) {
-  value = byte_swap<value_type, endian>(value);
-  memcpy(LLVM_ASSUME_ALIGNED(
-             memory, (detail::PickAlignment<value_type, alignment>::value)),
-         &value, sizeof(value_type));
+  write<value_type, alignment>(memory, value, endian);
 }
 
+template <typename value_type>
+using make_unsigned_t = std::make_unsigned_t<value_type>;
+
 /// Read a value of a particular endianness from memory, for a location
 /// that starts at the given bit offset within the first byte.
 template <typename value_type, endianness endian, std::size_t alignment>
@@ -152,15 +131,15 @@
     val[1] = byte_swap<value_type, endian>(val[1]);
 
     // Shift bits from the lower value into place.
-    std::make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
+    make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
     // Mask off upper bits after right shift in case of signed type.
-    std::make_unsigned_t<value_type> numBitsFirstVal =
+    make_unsigned_t<value_type> numBitsFirstVal =
         (sizeof(value_type) * 8) - startBit;
-    lowerVal &= ((std::make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
+    lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
 
     // Get the bits from the upper value.
-    std::make_unsigned_t<value_type> upperVal =
-        val[1] & (((std::make_unsigned_t<value_type>)1 << startBit) - 1);
+    make_unsigned_t<value_type> upperVal =
+        val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
     // Shift them in to place.
     upperVal <<= numBitsFirstVal;
 
@@ -188,15 +167,15 @@
 
     // Mask off any existing bits in the upper part of the lower value that
     // we want to replace.
-    val[0] &= ((std::make_unsigned_t<value_type>)1 << startBit) - 1;
-    std::make_unsigned_t<value_type> numBitsFirstVal =
+    val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
+    make_unsigned_t<value_type> numBitsFirstVal =
         (sizeof(value_type) * 8) - startBit;
-    std::make_unsigned_t<value_type> lowerVal = value;
+    make_unsigned_t<value_type> lowerVal = value;
     if (startBit > 0) {
       // Mask off the upper bits in the new value that are not going to go into
       // the lower value. This avoids a left shift of a negative value, which
       // is undefined behavior.
-      lowerVal &= (((std::make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
+      lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
       // Now shift the new bits into place
       lowerVal <<= startBit;
     }
@@ -204,11 +183,11 @@
 
     // Mask off any existing bits in the lower part of the upper value that
     // we want to replace.
-    val[1] &= ~(((std::make_unsigned_t<value_type>)1 << startBit) - 1);
+    val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
     // Next shift the bits that go into the upper value into position.
-    std::make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
+    make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
     // Mask off upper bits after right shift in case of signed type.
-    upperVal &= ((std::make_unsigned_t<value_type>)1 << startBit) - 1;
+    upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
     val[1] |= upperVal;
 
     // Finally, rewrite values.
@@ -224,10 +203,13 @@
 
 namespace detail {
 
-template<typename value_type,
-         endianness endian,
-         std::size_t alignment>
+template <typename ValueType, endianness Endian, std::size_t Alignment,
+          std::size_t ALIGN = PickAlignment<ValueType, Alignment>::value>
 struct packed_endian_specific_integral {
+  using value_type = ValueType;
+  static constexpr endianness endian = Endian;
+  static constexpr std::size_t alignment = Alignment;
+
   packed_endian_specific_integral() = default;
 
   explicit packed_endian_specific_integral(value_type val) { *this = val; }
@@ -263,8 +245,9 @@
   }
 
 private:
-  AlignedCharArray<PickAlignment<value_type, alignment>::value,
-                   sizeof(value_type)> Value;
+  struct {
+    alignas(ALIGN) char buffer[sizeof(value_type)];
+  } Value;
 
 public:
   struct ref {
@@ -355,6 +338,17 @@
 using unaligned_int64_t =
     detail::packed_endian_specific_integral<int64_t, native, unaligned>;
 
+template <typename T>
+using little_t = detail::packed_endian_specific_integral<T, little, unaligned>;
+template <typename T>
+using big_t = detail::packed_endian_specific_integral<T, big, unaligned>;
+
+template <typename T>
+using aligned_little_t =
+    detail::packed_endian_specific_integral<T, little, aligned>;
+template <typename T>
+using aligned_big_t = detail::packed_endian_specific_integral<T, big, aligned>;
+
 namespace endian {
 
 template <typename T> inline T read(const void *P, endianness E) {
diff --git a/wpiutil/src/main/native/include/wpi/EpochTracker.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/EpochTracker.h
similarity index 83%
rename from wpiutil/src/main/native/include/wpi/EpochTracker.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/EpochTracker.h
index b26800b..6417c05 100644
--- a/wpiutil/src/main/native/include/wpi/EpochTracker.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/EpochTracker.h
@@ -1,41 +1,27 @@
 //===- llvm/ADT/EpochTracker.h - ADT epoch tracking --------------*- C++ -*-==//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the DebugEpochBase and DebugEpochBase::HandleBase classes.
-// These can be used to write iterators that are fail-fast when LLVM is built
-// with asserts enabled.
-//
+///
+/// \file
+/// This file defines the DebugEpochBase and DebugEpochBase::HandleBase classes.
+/// These can be used to write iterators that are fail-fast when LLVM is built
+/// with asserts enabled.
+///
 //===----------------------------------------------------------------------===//
 
-#ifndef WPIUTIL_WPI_EPOCH_TRACKER_H
-#define WPIUTIL_WPI_EPOCH_TRACKER_H
+#ifndef WPIUTIL_WPI_EPOCHTRACKER_H
+#define WPIUTIL_WPI_EPOCHTRACKER_H
+
 
 #include <cstdint>
 
 namespace wpi {
 
-#ifdef NDEBUG //ifndef LLVM_ENABLE_ABI_BREAKING_CHECKS
-
-class DebugEpochBase {
-public:
-  void incrementEpoch() {}
-
-  class HandleBase {
-  public:
-    HandleBase() = default;
-    explicit HandleBase(const DebugEpochBase *) {}
-    bool isHandleInSync() const { return true; }
-    const void *getEpochAddress() const { return nullptr; }
-  };
-};
-
-#else
+#ifndef NDEBUG //ifndef LLVM_ENABLE_ABI_BREAKING_CHECKS
 
 /// A base class for data structure classes wishing to make iterators
 /// ("handles") pointing into themselves fail-fast.  When building without
@@ -90,6 +76,21 @@
   };
 };
 
+#else
+
+class DebugEpochBase {
+public:
+  void incrementEpoch() {}
+
+  class HandleBase {
+  public:
+    HandleBase() = default;
+    explicit HandleBase(const DebugEpochBase *) {}
+    bool isHandleInSync() const { return true; }
+    const void *getEpochAddress() const { return nullptr; }
+  };
+};
+
 #endif // LLVM_ENABLE_ABI_BREAKING_CHECKS
 
 } // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/Errc.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errc.h
similarity index 88%
rename from wpiutil/src/main/native/include/wpi/Errc.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errc.h
index ebce58a..dee28df 100644
--- a/wpiutil/src/main/native/include/wpi/Errc.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errc.h
@@ -1,9 +1,8 @@
-//===- llvm/Support/Errc.h - Defines the llvm::errc enum --------*- C++ -*-===//
+//===- llvm/Support/Errc.h - Defines the wpi::errc enum --------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -11,7 +10,7 @@
 // some problems with std::errc that can be avoided by using our own
 // enumeration:
 //
-// * std::errc is a namespace in some implementations. That meas that ADL
+// * std::errc is a namespace in some implementations. That means that ADL
 //   doesn't work and it is sometimes necessary to write std::make_error_code
 //   or in templates:
 //   using std::make_error_code;
@@ -23,7 +22,7 @@
 //   the intersection of all the ones we support.
 //
 // * std::errc is just marked with is_error_condition_enum. This means that
-//   common patters like AnErrorCode == errc::no_such_file_or_directory take
+//   common patterns like AnErrorCode == errc::no_such_file_or_directory take
 //   4 virtual calls instead of two comparisons.
 //===----------------------------------------------------------------------===//
 
diff --git a/wpiutil/src/main/native/include/wpi/Errno.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errno.h
similarity index 66%
rename from wpiutil/src/main/native/include/wpi/Errno.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errno.h
index 042d432..febfc37 100644
--- a/wpiutil/src/main/native/include/wpi/Errno.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Errno.h
@@ -1,9 +1,8 @@
 //===- llvm/Support/Errno.h - Portable+convenient errno handling -*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -22,8 +21,8 @@
 namespace sys {
 
 template <typename FailT, typename Fun, typename... Args>
-inline auto RetryAfterSignal(const FailT &Fail, const Fun &F,
-                             const Args &... As) -> decltype(F(As...)) {
+inline decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F,
+                                       const Args &... As) {
   decltype(F(As...)) Res;
   do {
     errno = 0;
@@ -35,4 +34,4 @@
 }  // namespace sys
 }  // namespace wpi
 
-#endif  // WPIUTIL_WPI_ERRNO_H
+#endif // WPIUTIL_WPI_ERRNO_H
diff --git a/wpiutil/src/main/native/include/wpi/ErrorHandling.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ErrorHandling.h
similarity index 79%
rename from wpiutil/src/main/native/include/wpi/ErrorHandling.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/ErrorHandling.h
index da9af4b..7b43671 100644
--- a/wpiutil/src/main/native/include/wpi/ErrorHandling.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ErrorHandling.h
@@ -1,9 +1,8 @@
 //===- llvm/Support/ErrorHandling.h - Fatal error handling ------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -20,9 +19,10 @@
 #include <string_view>
 
 namespace wpi {
+
   /// An error handler callback.
   typedef void (*fatal_error_handler_t)(void *user_data,
-                                        const std::string& reason,
+                                        const char *reason,
                                         bool gen_crash_diag);
 
   /// install_fatal_error_handler - Installs a new error handler to be used
@@ -65,14 +65,14 @@
 ///
 /// If no error handler is installed the default is to print the message to
 /// standard error, followed by a newline.
-/// After the error handler is called this function will call exit(1), it
+/// After the error handler is called this function will call abort(), it
 /// does not return.
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason,
-                                                bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const std::string &reason,
-                                                bool gen_crash_diag = true);
-LLVM_ATTRIBUTE_NORETURN void report_fatal_error(std::string_view reason,
-                                                bool gen_crash_diag = true);
+[[noreturn]] void report_fatal_error(const char *reason,
+                                     bool gen_crash_diag = true);
+[[noreturn]] void report_fatal_error(const std::string &reason,
+                                     bool gen_crash_diag = true);
+[[noreturn]] void report_fatal_error(std::string_view reason,
+                                     bool gen_crash_diag = true);
 
 /// Installs a new bad alloc error handler that should be used whenever a
 /// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM.
@@ -100,31 +100,32 @@
 
 /// Reports a bad alloc error, calling any user defined bad alloc
 /// error handler. In contrast to the generic 'report_fatal_error'
-/// functions, this function is expected to return, e.g. the user
-/// defined error handler throws an exception.
+/// functions, this function might not terminate, e.g. the user
+/// defined error handler throws an exception, but it won't return.
 ///
 /// Note: When throwing an exception in the bad alloc handler, make sure that
 /// the following unwind succeeds, e.g. do not trigger additional allocations
 /// in the unwind chain.
 ///
-/// If no error handler is installed (default), then a bad_alloc exception
-/// is thrown, if LLVM is compiled with exception support, otherwise an
-/// assertion is called.
-void report_bad_alloc_error(const char *Reason, bool GenCrashDiag = true);
+/// If no error handler is installed (default), throws a bad_alloc exception
+/// if LLVM is compiled with exception support. Otherwise prints the error
+/// to standard error and calls abort().
+[[noreturn]] void report_bad_alloc_error(const char *Reason,
+                                         bool GenCrashDiag = true);
 
 /// This function calls abort(), and prints the optional message to stderr.
 /// Use the wpi_unreachable macro (that adds location info), instead of
 /// calling this function directly.
-LLVM_ATTRIBUTE_NORETURN void
+[[noreturn]] void
 wpi_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
-                         unsigned line = 0);
+                          unsigned line = 0);
 }
 
 /// Marks that the current location is not supposed to be reachable.
 /// In !NDEBUG builds, prints the message and location info to stderr.
 /// In NDEBUG builds, becomes an optimizer hint that the current location
 /// is not supposed to be reachable.  On compilers that don't support
-/// such hints, prints a reduced message instead.
+/// such hints, prints a reduced message instead and aborts the program.
 ///
 /// Use this instead of assert(0).  It conveys intent more clearly and
 /// allows compilers to omit some unnecessary code.
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/FunctionExtras.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/FunctionExtras.h
new file mode 100644
index 0000000..681b87e
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/FunctionExtras.h
@@ -0,0 +1,427 @@
+//===- FunctionExtras.h - Function type erasure utilities -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file provides a collection of function (or more generally, callable)
+/// type erasure utilities supplementing those provided by the standard library
+/// in `<function>`.
+///
+/// It provides `unique_function`, which works like `std::function` but supports
+/// move-only callable objects and const-qualification.
+///
+/// Future plans:
+/// - Add a `function` that provides ref-qualified support, which doesn't work
+///   with `std::function`.
+/// - Provide support for specifying multiple signatures to type erase callable
+///   objects with an overload set, such as those produced by generic lambdas.
+/// - Expand to include a copyable utility that directly replaces std::function
+///   but brings the above improvements.
+///
+/// Note that LLVM's utilities are greatly simplified by not supporting
+/// allocators.
+///
+/// If the standard library ever begins to provide comparable facilities we can
+/// consider switching to those.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_FUNCTIONEXTRAS_H
+#define WPIUTIL_WPI_FUNCTIONEXTRAS_H
+
+#include "wpi/PointerIntPair.h"
+#include "wpi/PointerUnion.h"
+#include "wpi/STLForwardCompat.h"
+#include "wpi/MemAlloc.h"
+#include "wpi/type_traits.h"
+#include <cstring>
+#include <memory>
+#include <type_traits>
+
+namespace wpi {
+
+/// unique_function is a type-erasing functor similar to std::function.
+///
+/// It can hold move-only function objects, like lambdas capturing unique_ptrs.
+/// Accordingly, it is movable but not copyable.
+///
+/// It supports const-qualification:
+/// - unique_function<int() const> has a const operator().
+///   It can only hold functions which themselves have a const operator().
+/// - unique_function<int()> has a non-const operator().
+///   It can hold functions with a non-const operator(), like mutable lambdas.
+template <typename FunctionT> class unique_function;
+
+// GCC warns on OutOfLineStorage
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+namespace detail {
+
+template <typename T>
+using EnableIfTrivial =
+    std::enable_if_t<wpi::is_trivially_move_constructible<T>::value &&
+                     std::is_trivially_destructible<T>::value>;
+template <typename CallableT, typename ThisT>
+using EnableUnlessSameType =
+    std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>;
+template <typename CallableT, typename Ret, typename... Params>
+using EnableIfCallable = std::enable_if_t<wpi::disjunction<
+    std::is_void<Ret>,
+    std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)),
+                 Ret>,
+    std::is_same<const decltype(std::declval<CallableT>()(
+                     std::declval<Params>()...)),
+                 Ret>,
+    std::is_convertible<decltype(std::declval<CallableT>()(
+                            std::declval<Params>()...)),
+                        Ret>>::value>;
+
+template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
+protected:
+  static constexpr size_t InlineStorageSize = sizeof(void *) * 4;
+
+  template <typename T, class = void>
+  struct IsSizeLessThanThresholdT : std::false_type {};
+
+  template <typename T>
+  struct IsSizeLessThanThresholdT<
+      T, std::enable_if_t<sizeof(T) <= 2 * sizeof(void *)>> : std::true_type {};
+
+  // Provide a type function to map parameters that won't observe extra copies
+  // or moves and which are small enough to likely pass in register to values
+  // and all other types to l-value reference types. We use this to compute the
+  // types used in our erased call utility to minimize copies and moves unless
+  // doing so would force things unnecessarily into memory.
+  //
+  // The heuristic used is related to common ABI register passing conventions.
+  // It doesn't have to be exact though, and in one way it is more strict
+  // because we want to still be able to observe either moves *or* copies.
+  template <typename T> struct AdjustedParamTBase {
+    static_assert(!std::is_reference<T>::value,
+                  "references should be handled by template specialization");
+    using type = typename std::conditional<
+        wpi::is_trivially_copy_constructible<T>::value &&
+            wpi::is_trivially_move_constructible<T>::value &&
+            IsSizeLessThanThresholdT<T>::value,
+        T, T &>::type;
+  };
+
+  // This specialization ensures that 'AdjustedParam<V<T>&>' or
+  // 'AdjustedParam<V<T>&&>' does not trigger a compile-time error when 'T' is
+  // an incomplete type and V a templated type.
+  template <typename T> struct AdjustedParamTBase<T &> { using type = T &; };
+  template <typename T> struct AdjustedParamTBase<T &&> { using type = T &; };
+
+  template <typename T>
+  using AdjustedParamT = typename AdjustedParamTBase<T>::type;
+
+  // The type of the erased function pointer we use as a callback to dispatch to
+  // the stored callable when it is trivial to move and destroy.
+  using CallPtrT = ReturnT (*)(void *CallableAddr,
+                               AdjustedParamT<ParamTs>... Params);
+  using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);
+  using DestroyPtrT = void (*)(void *CallableAddr);
+
+  /// A struct to hold a single trivial callback with sufficient alignment for
+  /// our bitpacking.
+  struct alignas(8) TrivialCallback {
+    CallPtrT CallPtr;
+  };
+
+  /// A struct we use to aggregate three callbacks when we need full set of
+  /// operations.
+  struct alignas(8) NonTrivialCallbacks {
+    CallPtrT CallPtr;
+    MovePtrT MovePtr;
+    DestroyPtrT DestroyPtr;
+  };
+
+  // Create a pointer union between either a pointer to a static trivial call
+  // pointer in a struct or a pointer to a static struct of the call, move, and
+  // destroy pointers.
+  using CallbackPointerUnionT =
+      PointerUnion<TrivialCallback *, NonTrivialCallbacks *>;
+
+  // The main storage buffer. This will either have a pointer to out-of-line
+  // storage or an inline buffer storing the callable.
+  union StorageUnionT {
+    // For out-of-line storage we keep a pointer to the underlying storage and
+    // the size. This is enough to deallocate the memory.
+    struct OutOfLineStorageT {
+      void *StoragePtr;
+      size_t Size;
+      size_t Alignment;
+    } OutOfLineStorage;
+    static_assert(
+        sizeof(OutOfLineStorageT) <= InlineStorageSize,
+        "Should always use all of the out-of-line storage for inline storage!");
+
+    // For in-line storage, we just provide an aligned character buffer. We
+    // provide four pointers worth of storage here.
+    // This is mutable as an inlined `const unique_function<void() const>` may
+    // still modify its own mutable members.
+    mutable
+        typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
+            InlineStorage;
+  } StorageUnion;
+
+  // A compressed pointer to either our dispatching callback or our table of
+  // dispatching callbacks and the flag for whether the callable itself is
+  // stored inline or not.
+  PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;
+
+  bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }
+
+  bool isTrivialCallback() const {
+    return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
+  }
+
+  CallPtrT getTrivialCallback() const {
+    return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
+  }
+
+  NonTrivialCallbacks *getNonTrivialCallbacks() const {
+    return CallbackAndInlineFlag.getPointer()
+        .template get<NonTrivialCallbacks *>();
+  }
+
+  CallPtrT getCallPtr() const {
+    return isTrivialCallback() ? getTrivialCallback()
+                               : getNonTrivialCallbacks()->CallPtr;
+  }
+
+  // These three functions are only const in the narrow sense. They return
+  // mutable pointers to function state.
+  // This allows unique_function<T const>::operator() to be const, even if the
+  // underlying functor may be internally mutable.
+  //
+  // const callers must ensure they're only used in const-correct ways.
+  void *getCalleePtr() const {
+    return isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();
+  }
+  void *getInlineStorage() const { return &StorageUnion.InlineStorage; }
+  void *getOutOfLineStorage() const {
+    return StorageUnion.OutOfLineStorage.StoragePtr;
+  }
+
+  size_t getOutOfLineStorageSize() const {
+    return StorageUnion.OutOfLineStorage.Size;
+  }
+  size_t getOutOfLineStorageAlignment() const {
+    return StorageUnion.OutOfLineStorage.Alignment;
+  }
+
+  void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
+    StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
+  }
+
+  template <typename CalledAsT>
+  static ReturnT CallImpl(void *CallableAddr,
+                          AdjustedParamT<ParamTs>... Params) {
+    auto &Func = *reinterpret_cast<CalledAsT *>(CallableAddr);
+    return Func(std::forward<ParamTs>(Params)...);
+  }
+
+  template <typename CallableT>
+  static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {
+    new (LHSCallableAddr)
+        CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
+  }
+
+  template <typename CallableT>
+  static void DestroyImpl(void *CallableAddr) noexcept {
+    reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();
+  }
+
+  // The pointers to call/move/destroy functions are determined for each
+  // callable type (and called-as type, which determines the overload chosen).
+  // (definitions are out-of-line).
+
+  // By default, we need an object that contains all the different
+  // type erased behaviors needed. Create a static instance of the struct type
+  // here and each instance will contain a pointer to it.
+  // Wrap in a struct to avoid https://gcc.gnu.org/PR71954
+  template <typename CallableT, typename CalledAs, typename Enable = void>
+  struct CallbacksHolder {
+    static NonTrivialCallbacks Callbacks;
+  };
+  // See if we can create a trivial callback. We need the callable to be
+  // trivially moved and trivially destroyed so that we don't have to store
+  // type erased callbacks for those operations.
+  template <typename CallableT, typename CalledAs>
+  struct CallbacksHolder<CallableT, CalledAs, EnableIfTrivial<CallableT>> {
+    static TrivialCallback Callbacks;
+  };
+
+  // A simple tag type so the call-as type to be passed to the constructor.
+  template <typename T> struct CalledAs {};
+
+  // Essentially the "main" unique_function constructor, but subclasses
+  // provide the qualified type to be used for the call.
+  // (We always store a T, even if the call will use a pointer to const T).
+  template <typename CallableT, typename CalledAsT>
+  UniqueFunctionBase(CallableT Callable, CalledAs<CalledAsT>) {
+    bool IsInlineStorage = true;
+    void *CallableAddr = getInlineStorage();
+    if (sizeof(CallableT) > InlineStorageSize ||
+        alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
+      IsInlineStorage = false;
+      // Allocate out-of-line storage. FIXME: Use an explicit alignment
+      // parameter in C++17 mode.
+      auto Size = sizeof(CallableT);
+      auto Alignment = alignof(CallableT);
+      CallableAddr = allocate_buffer(Size, Alignment);
+      setOutOfLineStorage(CallableAddr, Size, Alignment);
+    }
+
+    // Now move into the storage.
+    new (CallableAddr) CallableT(std::move(Callable));
+    CallbackAndInlineFlag.setPointerAndInt(
+        &CallbacksHolder<CallableT, CalledAsT>::Callbacks, IsInlineStorage);
+  }
+
+  ~UniqueFunctionBase() {
+    if (!CallbackAndInlineFlag.getPointer())
+      return;
+
+    // Cache this value so we don't re-check it after type-erased operations.
+    bool IsInlineStorage = isInlineStorage();
+
+    if (!isTrivialCallback())
+      getNonTrivialCallbacks()->DestroyPtr(
+          IsInlineStorage ? getInlineStorage() : getOutOfLineStorage());
+
+    if (!IsInlineStorage)
+      deallocate_buffer(getOutOfLineStorage(), getOutOfLineStorageSize(),
+                        getOutOfLineStorageAlignment());
+  }
+
+  UniqueFunctionBase(UniqueFunctionBase &&RHS) noexcept {
+    // Copy the callback and inline flag.
+    CallbackAndInlineFlag = RHS.CallbackAndInlineFlag;
+
+    // If the RHS is empty, just copying the above is sufficient.
+    if (!RHS)
+      return;
+
+    if (!isInlineStorage()) {
+      // The out-of-line case is easiest to move.
+      StorageUnion.OutOfLineStorage = RHS.StorageUnion.OutOfLineStorage;
+    } else if (isTrivialCallback()) {
+      // Move is trivial, just memcpy the bytes across.
+      memcpy(getInlineStorage(), RHS.getInlineStorage(), InlineStorageSize);
+    } else {
+      // Non-trivial move, so dispatch to a type-erased implementation.
+      getNonTrivialCallbacks()->MovePtr(getInlineStorage(),
+                                        RHS.getInlineStorage());
+    }
+
+    // Clear the old callback and inline flag to get back to as-if-null.
+    RHS.CallbackAndInlineFlag = {};
+
+#ifndef NDEBUG
+    // In debug builds, we also scribble across the rest of the storage.
+    memset(RHS.getInlineStorage(), 0xAD, InlineStorageSize);
+#endif
+  }
+
+  UniqueFunctionBase &operator=(UniqueFunctionBase &&RHS) noexcept {
+    if (this == &RHS)
+      return *this;
+
+    // Because we don't try to provide any exception safety guarantees we can
+    // implement move assignment very simply by first destroying the current
+    // object and then move-constructing over top of it.
+    this->~UniqueFunctionBase();
+    new (this) UniqueFunctionBase(std::move(RHS));
+    return *this;
+  }
+
+  UniqueFunctionBase() = default;
+
+public:
+  explicit operator bool() const {
+    return (bool)CallbackAndInlineFlag.getPointer();
+  }
+};
+
+template <typename R, typename... P>
+template <typename CallableT, typename CalledAsT, typename Enable>
+typename UniqueFunctionBase<R, P...>::NonTrivialCallbacks UniqueFunctionBase<
+    R, P...>::CallbacksHolder<CallableT, CalledAsT, Enable>::Callbacks = {
+    &CallImpl<CalledAsT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
+
+template <typename R, typename... P>
+template <typename CallableT, typename CalledAsT>
+typename UniqueFunctionBase<R, P...>::TrivialCallback
+    UniqueFunctionBase<R, P...>::CallbacksHolder<
+        CallableT, CalledAsT, EnableIfTrivial<CallableT>>::Callbacks{
+        &CallImpl<CalledAsT>};
+
+} // namespace detail
+
+template <typename R, typename... P>
+class unique_function<R(P...)> : public detail::UniqueFunctionBase<R, P...> {
+  using Base = detail::UniqueFunctionBase<R, P...>;
+
+public:
+  unique_function() = default;
+  unique_function(std::nullptr_t) {}
+  unique_function(unique_function &&) = default;
+  unique_function(const unique_function &) = delete;
+  unique_function &operator=(unique_function &&) = default;
+  unique_function &operator=(const unique_function &) = delete;
+
+  template <typename CallableT>
+  unique_function(
+      CallableT Callable,
+      detail::EnableUnlessSameType<CallableT, unique_function> * = nullptr,
+      detail::EnableIfCallable<CallableT, R, P...> * = nullptr)
+      : Base(std::forward<CallableT>(Callable),
+             typename Base::template CalledAs<CallableT>{}) {}
+
+  R operator()(P... Params) {
+    return this->getCallPtr()(this->getCalleePtr(), Params...);
+  }
+};
+
+template <typename R, typename... P>
+class unique_function<R(P...) const>
+    : public detail::UniqueFunctionBase<R, P...> {
+  using Base = detail::UniqueFunctionBase<R, P...>;
+
+public:
+  unique_function() = default;
+  unique_function(std::nullptr_t) {}
+  unique_function(unique_function &&) = default;
+  unique_function(const unique_function &) = delete;
+  unique_function &operator=(unique_function &&) = default;
+  unique_function &operator=(const unique_function &) = delete;
+
+  template <typename CallableT>
+  unique_function(
+      CallableT Callable,
+      detail::EnableUnlessSameType<CallableT, unique_function> * = nullptr,
+      detail::EnableIfCallable<const CallableT, R, P...> * = nullptr)
+      : Base(std::forward<CallableT>(Callable),
+             typename Base::template CalledAs<const CallableT>{}) {}
+
+  R operator()(P... Params) const {
+    return this->getCallPtr()(this->getCalleePtr(), Params...);
+  }
+};
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_FUNCTIONEXTRAS_H
diff --git a/wpiutil/src/main/native/include/wpi/Hashing.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Hashing.h
similarity index 90%
rename from wpiutil/src/main/native/include/wpi/Hashing.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/Hashing.h
index e58bfdd..0d4a4c6 100644
--- a/wpiutil/src/main/native/include/wpi/Hashing.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/Hashing.h
@@ -1,9 +1,8 @@
 //===-- llvm/ADT/Hashing.h - Utilities for hashing --------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -45,15 +44,14 @@
 #ifndef WPIUTIL_WPI_HASHING_H
 #define WPIUTIL_WPI_HASHING_H
 
-#include "wpi/Endian.h"
+#include "wpi/ErrorHandling.h"
 #include "wpi/SwapByteOrder.h"
 #include "wpi/type_traits.h"
-#include <stdint.h>
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <string>
-#include <string_view>
+#include <tuple>
 #include <utility>
 
 #ifdef _WIN32
@@ -62,6 +60,7 @@
 #endif
 
 namespace wpi {
+template <typename T, typename Enable> struct DenseMapInfo;
 
 /// An opaque object representing a hash code.
 ///
@@ -108,8 +107,7 @@
 /// differing argument types even if they would implicit promote to a common
 /// type without changing the value.
 template <typename T>
-typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type
-hash_value(T value);
+std::enable_if_t<is_integral_or_enum<T>::value, hash_code> hash_value(T value);
 
 /// Compute a hash_code for a pointer's address.
 ///
@@ -120,6 +118,10 @@
 template <typename T, typename U>
 hash_code hash_value(const std::pair<T, U> &arg);
 
+/// Compute a hash_code for a tuple.
+template <typename... Ts>
+hash_code hash_value(const std::tuple<Ts...> &arg);
+
 /// Compute a hash_code for a standard string.
 template <typename T>
 hash_code hash_value(const std::basic_string<T> &arg);
@@ -151,7 +153,7 @@
 inline uint64_t fetch64(const char *p) {
   uint64_t result;
   memcpy(&result, p, sizeof(result));
-  if (support::endian::system_endianness() == support::big)
+  if (sys::IsBigEndianHost)
     sys::swapByteOrder(result);
   return result;
 }
@@ -159,16 +161,16 @@
 inline uint32_t fetch32(const char *p) {
   uint32_t result;
   memcpy(&result, p, sizeof(result));
-  if (support::endian::system_endianness() == support::big)
+  if (sys::IsBigEndianHost)
     sys::swapByteOrder(result);
   return result;
 }
 
 /// Some primes between 2^63 and 2^64 for various uses.
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t k1 = 0xb492b66fbe98f273ULL;
-static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
-static const uint64_t k3 = 0xc949d7c7509e6557ULL;
+static constexpr uint64_t k0 = 0xc3a5c85c97cb3127ULL;
+static constexpr uint64_t k1 = 0xb492b66fbe98f273ULL;
+static constexpr uint64_t k2 = 0x9ae16a3b2f90404fULL;
+static constexpr uint64_t k3 = 0xc949d7c7509e6557ULL;
 
 /// Bitwise right rotate.
 /// Normally this will compile to a single instruction, especially if the
@@ -198,7 +200,7 @@
   uint8_t b = s[len >> 1];
   uint8_t c = s[len - 1];
   uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
-  uint32_t z = static_cast<uint32_t>(len + (static_cast<uint64_t>(c) << 2));
+  uint32_t z = static_cast<uint32_t>(len) + (static_cast<uint32_t>(c) << 2);
   return shift_mix(y * k2 ^ z * k3 ^ seed) * k2;
 }
 
@@ -264,7 +266,7 @@
 /// Currently, the algorithm for computing hash codes is based on CityHash and
 /// keeps 56 bytes of arbitrary state.
 struct hash_state {
-  uint64_t h0, h1, h2, h3, h4, h5, h6;
+  uint64_t h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0;
 
   /// Create a new hash_state structure and initialize it based on the
   /// seed and the first 64-byte chunk.
@@ -367,7 +369,7 @@
 /// Helper to get the hashable data representation for a type.
 /// This variant is enabled when the type itself can be used.
 template <typename T>
-typename std::enable_if<is_hashable_data<T>::value, T>::type
+std::enable_if_t<is_hashable_data<T>::value, T>
 get_hashable_data(const T &value) {
   return value;
 }
@@ -375,7 +377,7 @@
 /// This variant is enabled when we must first call hash_value and use the
 /// result as our data.
 template <typename T>
-typename std::enable_if<!is_hashable_data<T>::value, size_t>::type
+std::enable_if_t<!is_hashable_data<T>::value, size_t>
 get_hashable_data(const T &value) {
   using ::wpi::hash_value;
   return hash_value(value);
@@ -449,7 +451,7 @@
 /// are stored in contiguous memory, this routine avoids copying each value
 /// and directly reads from the underlying memory.
 template <typename ValueT>
-typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type
+std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
 hash_combine_range_impl(ValueT *first, ValueT *last) {
   const uint64_t seed = get_execution_seed();
   const char *s_begin = reinterpret_cast<const char *>(first);
@@ -499,7 +501,7 @@
 /// useful at minimizing the code in the recursive calls to ease the pain
 /// caused by a lack of variadic functions.
 struct hash_combine_recursive_helper {
-  char buffer[64];
+  char buffer[64] = {};
   hash_state state;
   const uint64_t seed;
 
@@ -547,7 +549,7 @@
       // store types smaller than the buffer.
       if (!store_and_advance(buffer_ptr, buffer_end, data,
                              partial_store_size))
-        abort();
+        wpi_unreachable("buffer smaller than stored type");
     }
     return buffer_ptr;
   }
@@ -574,7 +576,7 @@
     // Check whether the entire set of values fit in the buffer. If so, we'll
     // use the optimized short hashing routine and skip state entirely.
     if (length == 0)
-      return static_cast<size_t>(hash_short(buffer, buffer_ptr - buffer, seed));
+      return hash_short(buffer, buffer_ptr - buffer, seed);
 
     // Mix the final buffer, rotating it if we did a partial fill in order to
     // simulate doing a mix of the last 64-bytes. That is how the algorithm
@@ -586,7 +588,7 @@
     state.mix(buffer);
     length += buffer_ptr - buffer;
 
-    return static_cast<size_t>(state.finalize(length));
+    return state.finalize(length);
   }
 };
 
@@ -625,7 +627,7 @@
   const uint64_t seed = get_execution_seed();
   const char *s = reinterpret_cast<const char *>(&value);
   const uint64_t a = fetch32(s);
-  return static_cast<size_t>(hash_16_bytes(seed + (a << 3), fetch32(s + 4)));
+  return hash_16_bytes(seed + (a << 3), fetch32(s + 4));
 }
 
 } // namespace detail
@@ -634,8 +636,7 @@
 // Declared and documented above, but defined here so that any of the hashing
 // infrastructure is available.
 template <typename T>
-typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type
-hash_value(T value) {
+std::enable_if_t<is_integral_or_enum<T>::value, hash_code> hash_value(T value) {
   return ::wpi::hashing::detail::hash_integer_value(
       static_cast<uint64_t>(value));
 }
@@ -654,6 +655,26 @@
   return hash_combine(arg.first, arg.second);
 }
 
+// Implementation details for the hash_value overload for std::tuple<...>(...).
+namespace hashing {
+namespace detail {
+
+template <typename... Ts, std::size_t... Indices>
+hash_code hash_value_tuple_helper(const std::tuple<Ts...> &arg,
+                                  std::index_sequence<Indices...>) {
+  return hash_combine(std::get<Indices>(arg)...);
+}
+
+} // namespace detail
+} // namespace hashing
+
+template <typename... Ts>
+hash_code hash_value(const std::tuple<Ts...> &arg) {
+  // TODO: Use std::apply when LLVM starts using C++17.
+  return ::wpi::hashing::detail::hash_value_tuple_helper(
+      arg, typename std::index_sequence_for<Ts...>());
+}
+
 // Declared and documented above, but defined here so that any of the hashing
 // infrastructure is available.
 template <typename T>
@@ -661,10 +682,12 @@
   return hash_combine_range(arg.begin(), arg.end());
 }
 
-template <typename T>
-hash_code hash_value(const std::basic_string_view<T> &arg) {
-  return hash_combine_range(arg.begin(), arg.end());
-}
+template <> struct DenseMapInfo<hash_code, void> {
+  static inline hash_code getEmptyKey() { return hash_code(-1); }
+  static inline hash_code getTombstoneKey() { return hash_code(-2); }
+  static unsigned getHashValue(hash_code val) { return val; }
+  static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
+};
 
 } // namespace wpi
 
diff --git a/wpiutil/src/main/native/include/wpi/MapVector.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MapVector.h
similarity index 93%
rename from wpiutil/src/main/native/include/wpi/MapVector.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/MapVector.h
index 34e0267..e4706c7 100644
--- a/wpiutil/src/main/native/include/wpi/MapVector.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MapVector.h
@@ -1,17 +1,17 @@
 //===- llvm/ADT/MapVector.h - Map w/ deterministic value order --*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file implements a map that provides insertion order iteration. The
-// interface is purposefully minimal. The key is assumed to be cheap to copy
-// and 2 copies are kept, one for indexing in a DenseMap, one for iteration in
-// a std::vector.
-//
+///
+/// \file
+/// This file implements a map that provides insertion order iteration. The
+/// interface is purposefully minimal. The key is assumed to be cheap to copy
+/// and 2 copies are kept, one for indexing in a DenseMap, one for iteration in
+/// a std::vector.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_MAPVECTOR_H
@@ -19,7 +19,6 @@
 
 #include "wpi/DenseMap.h"
 #include "wpi/SmallVector.h"
-#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <iterator>
@@ -44,6 +43,7 @@
       "The mapped_type of the specified Map must be an integral type");
 
 public:
+  using key_type = KeyT;
   using value_type = typename VectorType::value_type;
   using size_type = typename VectorType::size_type;
 
@@ -237,4 +237,4 @@
 
 } // end namespace wpi
 
-#endif // LLVM_ADT_MAPVECTOR_H
+#endif // WPIUTIL_WPI_MAPVECTOR_H
diff --git a/wpiutil/src/main/native/include/wpi/MathExtras.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MathExtras.h
similarity index 81%
rename from wpiutil/src/main/native/include/wpi/MathExtras.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/MathExtras.h
index ac88cb9..ea669ee 100644
--- a/wpiutil/src/main/native/include/wpi/MathExtras.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MathExtras.h
@@ -1,9 +1,8 @@
 //===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,15 +14,18 @@
 #define WPIUTIL_WPI_MATHEXTRAS_H
 
 #include "wpi/Compiler.h"
-#include <cstdint>
-#include <algorithm>
 #include <cassert>
 #include <climits>
 #include <cmath>
+#include <cstdint>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
+#ifdef __ANDROID_NDK__
+#include <android/api-level.h>
+#endif
+
 #ifdef _MSC_VER
 // Declare these intrinsics manually rather including intrin.h. It's very
 // expensive, and MathExtras.h is popular.
@@ -37,6 +39,7 @@
 #endif
 
 namespace wpi {
+
 /// The behavior an operation has on an input of 0.
 enum ZeroBehavior {
   /// The returned value is undefined.
@@ -49,14 +52,14 @@
 
 namespace detail {
 template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
-  static std::size_t count(T Val, ZeroBehavior) {
+  static unsigned count(T Val, ZeroBehavior) {
     if (!Val)
       return std::numeric_limits<T>::digits;
     if (Val & 0x1)
       return 0;
 
     // Bisection method.
-    std::size_t ZeroBits = 0;
+    unsigned ZeroBits = 0;
     T Shift = std::numeric_limits<T>::digits >> 1;
     T Mask = (std::numeric_limits<T>::max)() >> Shift;
     while (Shift) {
@@ -71,13 +74,13 @@
   }
 };
 
-#if __GNUC__ >= 4 || defined(_MSC_VER)
+#if defined(__GNUC__) || defined(_MSC_VER)
 template <typename T> struct TrailingZerosCounter<T, 4> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
+  static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 32;
 
-#if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_ctz) || defined(__GNUC__)
     return __builtin_ctz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -89,11 +92,11 @@
 
 #if !defined(_MSC_VER) || defined(_M_X64)
 template <typename T> struct TrailingZerosCounter<T, 8> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
+  static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 64;
 
-#if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_ctzll) || defined(__GNUC__)
     return __builtin_ctzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -114,7 +117,7 @@
 /// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
 ///   valid arguments.
 template <typename T>
-std::size_t countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+unsigned countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
   static_assert(std::numeric_limits<T>::is_integer &&
                     !std::numeric_limits<T>::is_signed,
                 "Only unsigned integral types are allowed.");
@@ -123,12 +126,12 @@
 
 namespace detail {
 template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
-  static std::size_t count(T Val, ZeroBehavior) {
+  static unsigned count(T Val, ZeroBehavior) {
     if (!Val)
       return std::numeric_limits<T>::digits;
 
     // Bisection method.
-    std::size_t ZeroBits = 0;
+    unsigned ZeroBits = 0;
     for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
       T Tmp = Val >> Shift;
       if (Tmp)
@@ -140,13 +143,13 @@
   }
 };
 
-#if __GNUC__ >= 4 || defined(_MSC_VER)
+#if defined(__GNUC__) || defined(_MSC_VER)
 template <typename T> struct LeadingZerosCounter<T, 4> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
+  static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 32;
 
-#if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_clz) || defined(__GNUC__)
     return __builtin_clz(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -158,11 +161,11 @@
 
 #if !defined(_MSC_VER) || defined(_M_X64)
 template <typename T> struct LeadingZerosCounter<T, 8> {
-  static std::size_t count(T Val, ZeroBehavior ZB) {
+  static unsigned count(T Val, ZeroBehavior ZB) {
     if (ZB != ZB_Undefined && Val == 0)
       return 64;
 
-#if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+#if __has_builtin(__builtin_clzll) || defined(__GNUC__)
     return __builtin_clzll(Val);
 #elif defined(_MSC_VER)
     unsigned long Index;
@@ -183,7 +186,7 @@
 /// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
 ///   valid arguments.
 template <typename T>
-std::size_t countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+unsigned countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
   static_assert(std::numeric_limits<T>::is_integer &&
                     !std::numeric_limits<T>::is_signed,
                 "Only unsigned integral types are allowed.");
@@ -273,6 +276,34 @@
   return Val;
 }
 
+#if __has_builtin(__builtin_bitreverse8)
+template<>
+inline uint8_t reverseBits<uint8_t>(uint8_t Val) {
+  return __builtin_bitreverse8(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse16)
+template<>
+inline uint16_t reverseBits<uint16_t>(uint16_t Val) {
+  return __builtin_bitreverse16(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse32)
+template<>
+inline uint32_t reverseBits<uint32_t>(uint32_t Val) {
+  return __builtin_bitreverse32(Val);
+}
+#endif
+
+#if __has_builtin(__builtin_bitreverse64)
+template<>
+inline uint64_t reverseBits<uint64_t>(uint64_t Val) {
+  return __builtin_bitreverse64(Val);
+}
+#endif
+
 // NOTE: The following support functions use the _32/_64 extensions instead of
 // type overloading so that signed and unsigned integers can be used without
 // ambiguity.
@@ -325,14 +356,12 @@
 /// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
 /// left too many places.
 template <unsigned N>
-constexpr inline typename std::enable_if<(N < 64), bool>::type
-isUInt(uint64_t X) {
+constexpr inline std::enable_if_t<(N < 64), bool> isUInt(uint64_t X) {
   static_assert(N > 0, "isUInt<0> doesn't make sense");
   return X < (UINT64_C(1) << (N));
 }
 template <unsigned N>
-constexpr inline typename std::enable_if<N >= 64, bool>::type
-isUInt(uint64_t X) {
+constexpr inline std::enable_if_t<N >= 64, bool> isUInt(uint64_t) {
   return true;
 }
 
@@ -379,7 +408,7 @@
 inline int64_t minIntN(int64_t N) {
   assert(N > 0 && N <= 64 && "integer width out of range");
 
-  return -(UINT64_C(1)<<(N-1));
+  return UINT64_C(1) + ~(UINT64_C(1) << (N - 1));
 }
 
 #ifdef _WIN32
@@ -450,7 +479,7 @@
 /// \param ZB the behavior on an input of all ones. Only ZB_Width and
 /// ZB_Undefined are valid arguments.
 template <typename T>
-std::size_t countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
+unsigned countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
   static_assert(std::numeric_limits<T>::is_integer &&
                     !std::numeric_limits<T>::is_signed,
                 "Only unsigned integral types are allowed.");
@@ -466,7 +495,7 @@
 /// \param ZB the behavior on an input of all ones. Only ZB_Width and
 /// ZB_Undefined are valid arguments.
 template <typename T>
-std::size_t countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
+unsigned countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
   static_assert(std::numeric_limits<T>::is_integer &&
                     !std::numeric_limits<T>::is_signed,
                 "Only unsigned integral types are allowed.");
@@ -478,7 +507,7 @@
   static unsigned count(T Value) {
     // Generic version, forward to 32 bits.
     static_assert(SizeOfT <= 4, "Not implemented!");
-#if __GNUC__ >= 4
+#if defined(__GNUC__)
     return __builtin_popcount(Value);
 #else
     uint32_t v = Value;
@@ -491,7 +520,7 @@
 
 template <typename T> struct PopulationCounter<T, 8> {
   static unsigned count(T Value) {
-#if __GNUC__ >= 4
+#if defined(__GNUC__)
     return __builtin_popcountll(Value);
 #else
     uint64_t v = Value;
@@ -515,6 +544,16 @@
   return detail::PopulationCounter<T, sizeof(T)>::count(Value);
 }
 
+/// Compile time Log2.
+/// Valid only for positive powers of two.
+template <size_t kValue> constexpr inline size_t CTLog2() {
+  static_assert(kValue > 0 && wpi::isPowerOf2_64(kValue),
+                "Value is not a valid power of 2");
+  return 1 + CTLog2<kValue / 2>();
+}
+
+template <> constexpr inline size_t CTLog2<1>() { return 0; }
+
 /// Return the log base 2 of the specified value.
 inline double Log2(double Value) {
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 18
@@ -551,15 +590,20 @@
 }
 
 /// Return the greatest common divisor of the values using Euclid's algorithm.
-inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
+template <typename T>
+inline T greatestCommonDivisor(T A, T B) {
   while (B) {
-    uint64_t T = B;
+    T Tmp = B;
     B = A % B;
-    A = T;
+    A = Tmp;
   }
   return A;
 }
 
+inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
+  return greatestCommonDivisor<uint64_t>(A, B);
+}
+
 /// This function takes a 64-bit integer and returns the bit equivalent double.
 inline double BitsToDouble(uint64_t Bits) {
   double D;
@@ -607,25 +651,6 @@
   return (A | B) & (1 + ~(A | B));
 }
 
-/// Aligns \c Addr to \c Alignment bytes, rounding up.
-///
-/// Alignment should be a power of two.  This method rounds up, so
-/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
-inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
-  assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&
-         "Alignment is not a power of two!");
-
-  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr);
-
-  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
-}
-
-/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
-/// bytes, rounding up.
-inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
-  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
-}
-
 /// Returns the next power of two (in 64-bits) that is strictly greater than A.
 /// Returns zero on overflow.
 inline uint64_t NextPowerOf2(uint64_t A) {
@@ -691,18 +716,10 @@
   return alignTo(Numerator, Denominator) / Denominator;
 }
 
-/// \c alignTo for contexts where a constant expression is required.
-/// \sa alignTo
-///
-/// \todo FIXME: remove when \c constexpr becomes really \c constexpr
-template <uint64_t Align>
-struct AlignTo {
-  static_assert(Align != 0u, "Align must be non-zero");
-  template <uint64_t Value>
-  struct from_value {
-    static const uint64_t value = (Value + Align - 1) / Align * Align;
-  };
-};
+/// Returns the integer nearest(Numerator / Denominator).
+inline uint64_t divideNearest(uint64_t Numerator, uint64_t Denominator) {
+  return (Numerator + (Denominator / 2)) / Denominator;
+}
 
 /// Returns the largest uint64_t less than or equal to \p Value and is
 /// \p Skew mod \p Align. \p Align must be non-zero
@@ -712,13 +729,6 @@
   return (Value - Skew) / Align * Align + Skew;
 }
 
-/// Returns the offset to the next integer (mod 2**64) that is greater than
-/// or equal to \p Value and is a multiple of \p Align. \p Align must be
-/// non-zero.
-inline uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align) {
-  return alignTo(Value, Align) - Value;
-}
-
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
 /// Requires 0 < B <= 32.
 template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
@@ -728,7 +738,7 @@
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B < 32.
+/// Requires 0 < B <= 32.
 inline int32_t SignExtend32(uint32_t X, unsigned B) {
   assert(B > 0 && "Bit width can't be 0.");
   assert(B <= 32 && "Bit width out of range.");
@@ -736,7 +746,7 @@
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
+/// Requires 0 < B <= 64.
 template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
   static_assert(B > 0, "Bit width can't be 0.");
   static_assert(B <= 64, "Bit width out of range.");
@@ -744,7 +754,7 @@
 }
 
 /// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
+/// Requires 0 < B <= 64.
 inline int64_t SignExtend64(uint64_t X, unsigned B) {
   assert(B > 0 && "Bit width can't be 0.");
   assert(B <= 64 && "Bit width out of range.");
@@ -754,16 +764,15 @@
 /// Subtract two unsigned integers, X and Y, of type T and return the absolute
 /// value of the result.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-AbsoluteDifference(T X, T Y) {
-  return (std::max)(X, Y) - (std::min)(X, Y);
+std::enable_if_t<std::is_unsigned<T>::value, T> AbsoluteDifference(T X, T Y) {
+  return X > Y ? (X - Y) : (Y - X);
 }
 
 /// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
 /// maximum representable value of T on overflow.  ResultOverflowed indicates if
 /// the result is larger than the maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -780,7 +789,7 @@
 /// maximum representable value of T on overflow.  ResultOverflowed indicates if
 /// the result is larger than the maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -826,7 +835,7 @@
 /// overflow. ResultOverflowed indicates if the result is larger than the
 /// maximum representable value of type T.
 template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
+std::enable_if_t<std::is_unsigned<T>::value, T>
 SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
   bool Dummy;
   bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
@@ -838,6 +847,89 @@
   return SaturatingAdd(A, Product, &Overflowed);
 }
 
+/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
+extern const float huge_valf;
+
+
+/// Add two signed integers, computing the two's complement truncated result,
+/// returning true if overflow occured.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> AddOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_add_overflow)
+  return __builtin_add_overflow(X, Y, &Result);
+#else
+  // Perform the unsigned addition.
+  using U = std::make_unsigned_t<T>;
+  const U UX = static_cast<U>(X);
+  const U UY = static_cast<U>(Y);
+  const U UResult = UX + UY;
+
+  // Convert to signed.
+  Result = static_cast<T>(UResult);
+
+  // Adding two positive numbers should result in a positive number.
+  if (X > 0 && Y > 0)
+    return Result <= 0;
+  // Adding two negatives should result in a negative number.
+  if (X < 0 && Y < 0)
+    return Result >= 0;
+  return false;
+#endif
+}
+
+/// Subtract two signed integers, computing the two's complement truncated
+/// result, returning true if an overflow ocurred.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> SubOverflow(T X, T Y, T &Result) {
+#if __has_builtin(__builtin_sub_overflow)
+  return __builtin_sub_overflow(X, Y, &Result);
+#else
+  // Perform the unsigned addition.
+  using U = std::make_unsigned_t<T>;
+  const U UX = static_cast<U>(X);
+  const U UY = static_cast<U>(Y);
+  const U UResult = UX - UY;
+
+  // Convert to signed.
+  Result = static_cast<T>(UResult);
+
+  // Subtracting a positive number from a negative results in a negative number.
+  if (X <= 0 && Y > 0)
+    return Result >= 0;
+  // Subtracting a negative number from a positive results in a positive number.
+  if (X >= 0 && Y < 0)
+    return Result <= 0;
+  return false;
+#endif
+}
+
+/// Multiply two signed integers, computing the two's complement truncated
+/// result, returning true if an overflow ocurred.
+template <typename T>
+std::enable_if_t<std::is_signed<T>::value, T> MulOverflow(T X, T Y, T &Result) {
+  // Perform the unsigned multiplication on absolute values.
+  using U = std::make_unsigned_t<T>;
+  const U UX = X < 0 ? (0 - static_cast<U>(X)) : static_cast<U>(X);
+  const U UY = Y < 0 ? (0 - static_cast<U>(Y)) : static_cast<U>(Y);
+  const U UResult = UX * UY;
+
+  // Convert to signed.
+  const bool IsNegative = (X < 0) ^ (Y < 0);
+  Result = IsNegative ? (0 - UResult) : UResult;
+
+  // If any of the args was 0, result is 0 and no overflow occurs.
+  if (UX == 0 || UY == 0)
+    return false;
+
+  // UX and UY are in [1, 2^n], where n is the number of digits.
+  // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for
+  // positive) divided by an argument compares to the other.
+  if (IsNegative)
+    return UX > (static_cast<U>((std::numeric_limits<T>::max)()) + U(1)) / UY;
+  else
+    return UX > (static_cast<U>((std::numeric_limits<T>::max)())) / UY;
+}
+
 // Typesafe implementation of the signum function.
 // Returns -1 if negative, 1 if positive, 0 if 0.
 template <typename T>
@@ -858,7 +950,6 @@
 constexpr T Lerp(const T& startValue, const T& endValue, double t) {
   return startValue + (endValue - startValue) * t;
 }
-
-} // namespace wpi
+} // End wpi namespace
 
 #endif
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemAlloc.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemAlloc.h
new file mode 100644
index 0000000..32909ff
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemAlloc.h
@@ -0,0 +1,100 @@
+//===- MemAlloc.h - Memory allocation functions -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines counterparts of C library allocation functions defined in
+/// the namespace 'std'. The new allocation functions crash on allocation
+/// failure instead of returning null pointer.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_MEMALLOC_H
+#define WPIUTIL_WPI_MEMALLOC_H
+
+#include "wpi/Compiler.h"
+#include "wpi/ErrorHandling.h"
+#include <cstdlib>
+
+namespace wpi {
+
+#ifdef _WIN32
+#pragma warning(push)
+// Warning on NONNULL, report is not known to abort
+#pragma warning(disable : 6387)
+#pragma warning(disable : 28196)
+#pragma warning(disable : 28183)
+#endif
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_malloc(size_t Sz) {
+  void *Result = std::malloc(Sz);
+  if (Result == nullptr) {
+    // It is implementation-defined whether allocation occurs if the space
+    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
+    // non-zero, if the space requested was zero.
+    if (Sz == 0)
+      return safe_malloc(1);
+    report_bad_alloc_error("Allocation failed");
+  }
+  return Result;
+}
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_calloc(size_t Count,
+                                                        size_t Sz) {
+  void *Result = std::calloc(Count, Sz);
+  if (Result == nullptr) {
+    // It is implementation-defined whether allocation occurs if the space
+    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
+    // non-zero, if the space requested was zero.
+    if (Count == 0 || Sz == 0)
+      return safe_malloc(1);
+    report_bad_alloc_error("Allocation failed");
+  }
+  return Result;
+}
+
+LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
+  void *Result = std::realloc(Ptr, Sz);
+  if (Result == nullptr) {
+    // It is implementation-defined whether allocation occurs if the space
+    // requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
+    // non-zero, if the space requested was zero.
+    if (Sz == 0)
+      return safe_malloc(1);
+    report_bad_alloc_error("Allocation failed");
+  }
+  return Result;
+}
+
+/// Allocate a buffer of memory with the given size and alignment.
+///
+/// When the compiler supports aligned operator new, this will use it to to
+/// handle even over-aligned allocations.
+///
+/// However, this doesn't make any attempt to leverage the fancier techniques
+/// like posix_memalign due to portability. It is mostly intended to allow
+/// compatibility with platforms that, after aligned allocation was added, use
+/// reduced default alignment.
+LLVM_ATTRIBUTE_RETURNS_NONNULL LLVM_ATTRIBUTE_RETURNS_NOALIAS void *
+allocate_buffer(size_t Size, size_t Alignment);
+
+/// Deallocate a buffer of memory with the given size and alignment.
+///
+/// If supported, this will used the sized delete operator. Also if supported,
+/// this will pass the alignment to the delete operator.
+///
+/// The pointer must have been allocated with the corresponding new operator,
+/// most likely using the above helper.
+void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment);
+
+} // namespace wpi
+
+#ifdef _WIN32
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemoryBuffer.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemoryBuffer.h
new file mode 100644
index 0000000..7907c07
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/MemoryBuffer.h
@@ -0,0 +1,239 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+//===--- MemoryBuffer.h - Memory Buffer Interface ---------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the MemoryBuffer interface.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <stdint.h>
+
+#include <cstddef>
+#include <memory>
+#include <span>
+#include <string_view>
+#include <system_error>
+
+// Duplicated from fs.h to avoid a dependency
+namespace fs {
+#if defined(_WIN32)
+// A Win32 HANDLE is a typedef of void*
+using file_t = void*;
+#else
+using file_t = int;
+#endif
+}  // namespace fs
+
+namespace wpi {
+
+class MemoryBufferRef;
+
+/// This interface provides simple read-only access to a block of memory, and
+/// provides simple methods for reading files and standard input into a memory
+/// buffer.
+class MemoryBuffer {
+  const uint8_t* m_bufferStart;  // Start of the buffer.
+  const uint8_t* m_bufferEnd;    // End of the buffer.
+
+ protected:
+  MemoryBuffer() = default;
+
+  void Init(const uint8_t* bufStart, const uint8_t* bufEnd);
+
+ public:
+  MemoryBuffer(const MemoryBuffer&) = delete;
+  MemoryBuffer& operator=(const MemoryBuffer&) = delete;
+  virtual ~MemoryBuffer();
+
+  const uint8_t* begin() const { return m_bufferStart; }
+  const uint8_t* end() const { return m_bufferEnd; }
+  size_t size() const { return m_bufferEnd - m_bufferStart; }
+
+  std::span<const uint8_t> GetBuffer() const { return {begin(), end()}; }
+
+  /// Return an identifier for this buffer, typically the filename it was read
+  /// from.
+  virtual std::string_view GetBufferIdentifier() const {
+    return "Unknown buffer";
+  }
+
+  /// Open the specified file as a MemoryBuffer, returning a new MemoryBuffer
+  /// if successful, otherwise returning null. If FileSize is specified, this
+  /// means that the client knows that the file exists and that it has the
+  /// specified size.
+  static std::unique_ptr<MemoryBuffer> GetFile(std::string_view filename,
+                                               std::error_code& ec,
+                                               int64_t fileSize = -1);
+
+  /// Read all of the specified file into a MemoryBuffer as a stream
+  /// (i.e. until EOF reached). This is useful for special files that
+  /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux).
+  static std::unique_ptr<MemoryBuffer> GetFileAsStream(
+      std::string_view filename, std::error_code& ec);
+
+  /// Given an already-open file descriptor, map some slice of it into a
+  /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize.
+  static std::unique_ptr<MemoryBuffer> GetOpenFileSlice(
+      fs::file_t f, std::string_view filename, std::error_code& ec,
+      uint64_t mapSize, int64_t offset);
+
+  /// Given an already-open file descriptor, read the file and return a
+  /// MemoryBuffer.
+  static std::unique_ptr<MemoryBuffer> GetOpenFile(fs::file_t f,
+                                                   std::string_view filename,
+                                                   std::error_code& ec,
+                                                   uint64_t fileSize);
+
+  /// Open the specified memory range as a MemoryBuffer.
+  static std::unique_ptr<MemoryBuffer> GetMemBuffer(
+      std::span<const uint8_t> inputData, std::string_view bufferName = "");
+
+  static std::unique_ptr<MemoryBuffer> GetMemBuffer(MemoryBufferRef ref);
+
+  /// Open the specified memory range as a MemoryBuffer, copying the contents
+  /// and taking ownership of it.
+  static std::unique_ptr<MemoryBuffer> GetMemBufferCopy(
+      std::span<const uint8_t> inputData, std::string_view bufferName = "");
+
+  /// Map a subrange of the specified file as a MemoryBuffer.
+  static std::unique_ptr<MemoryBuffer> GetFileSlice(std::string_view filename,
+                                                    std::error_code& ec,
+                                                    uint64_t mapSize,
+                                                    uint64_t offset);
+
+  //===--------------------------------------------------------------------===//
+  // Provided for performance analysis.
+  //===--------------------------------------------------------------------===//
+
+  /// The kind of memory backing used to support the MemoryBuffer.
+  enum BufferKind { MemoryBuffer_Malloc, MemoryBuffer_MMap };
+
+  /// Return information on the memory mechanism used to support the
+  /// MemoryBuffer.
+  virtual BufferKind GetBufferKind() const = 0;
+
+  MemoryBufferRef GetMemBufferRef() const;
+};
+
+/// This class is an extension of MemoryBuffer, which allows copy-on-write
+/// access to the underlying contents.  It only supports creation methods that
+/// are guaranteed to produce a writable buffer.  For example, mapping a file
+/// read-only is not supported.
+class WritableMemoryBuffer : public MemoryBuffer {
+ protected:
+  WritableMemoryBuffer() = default;
+
+ public:
+  using MemoryBuffer::begin;
+  using MemoryBuffer::end;
+  using MemoryBuffer::GetBuffer;
+  using MemoryBuffer::size;
+
+  // const_cast is well-defined here, because the underlying buffer is
+  // guaranteed to have been initialized with a mutable buffer.
+  uint8_t* begin() { return const_cast<uint8_t*>(MemoryBuffer::begin()); }
+  uint8_t* end() { return const_cast<uint8_t*>(MemoryBuffer::end()); }
+  std::span<uint8_t> GetBuffer() { return {begin(), end()}; }
+
+  static std::unique_ptr<WritableMemoryBuffer> GetFile(
+      std::string_view filename, std::error_code& ec, int64_t fileSize = -1);
+
+  /// Map a subrange of the specified file as a WritableMemoryBuffer.
+  static std::unique_ptr<WritableMemoryBuffer> GetFileSlice(
+      std::string_view filename, std::error_code& ec, uint64_t mapSize,
+      uint64_t offset);
+
+  /// Allocate a new MemoryBuffer of the specified size that is not initialized.
+  /// Note that the caller should initialize the memory allocated by this
+  /// method. The memory is owned by the MemoryBuffer object.
+  static std::unique_ptr<WritableMemoryBuffer> GetNewUninitMemBuffer(
+      size_t size, std::string_view bufferName = "");
+
+  /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note
+  /// that the caller need not initialize the memory allocated by this method.
+  /// The memory is owned by the MemoryBuffer object.
+  static std::unique_ptr<WritableMemoryBuffer> GetNewMemBuffer(
+      size_t size, std::string_view bufferName = "");
+
+ private:
+  // Hide these base class factory function so one can't write
+  //   WritableMemoryBuffer::getXXX()
+  // and be surprised that they got a read-only Buffer.
+  using MemoryBuffer::GetFileAsStream;
+  using MemoryBuffer::GetMemBuffer;
+  using MemoryBuffer::GetMemBufferCopy;
+  using MemoryBuffer::GetOpenFile;
+  using MemoryBuffer::GetOpenFileSlice;
+};
+
+/// This class is an extension of MemoryBuffer, which allows write access to
+/// the underlying contents and committing those changes to the original source.
+/// It only supports creation methods that are guaranteed to produce a writable
+/// buffer.  For example, mapping a file read-only is not supported.
+class WriteThroughMemoryBuffer : public MemoryBuffer {
+ protected:
+  WriteThroughMemoryBuffer() = default;
+
+ public:
+  using MemoryBuffer::begin;
+  using MemoryBuffer::end;
+  using MemoryBuffer::GetBuffer;
+  using MemoryBuffer::size;
+
+  // const_cast is well-defined here, because the underlying buffer is
+  // guaranteed to have been initialized with a mutable buffer.
+  uint8_t* begin() { return const_cast<uint8_t*>(MemoryBuffer::begin()); }
+  uint8_t* end() { return const_cast<uint8_t*>(MemoryBuffer::end()); }
+  std::span<uint8_t> GetBuffer() { return {begin(), end()}; }
+
+  static std::unique_ptr<WriteThroughMemoryBuffer> GetFile(
+      std::string_view filename, std::error_code& ec, int64_t fileSize = -1);
+
+  /// Map a subrange of the specified file as a ReadWriteMemoryBuffer.
+  static std::unique_ptr<WriteThroughMemoryBuffer> GetFileSlice(
+      std::string_view filename, std::error_code& ec, uint64_t mapSize,
+      uint64_t offset);
+
+ private:
+  // Hide these base class factory function so one can't write
+  //   WritableMemoryBuffer::getXXX()
+  // and be surprised that they got a read-only Buffer.
+  using MemoryBuffer::GetFileAsStream;
+  using MemoryBuffer::GetMemBuffer;
+  using MemoryBuffer::GetMemBufferCopy;
+  using MemoryBuffer::GetOpenFile;
+  using MemoryBuffer::GetOpenFileSlice;
+};
+
+class MemoryBufferRef {
+  std::span<const uint8_t> m_buffer;
+  std::string_view m_id;
+
+ public:
+  MemoryBufferRef() = default;
+  MemoryBufferRef(MemoryBuffer& buffer)  // NOLINT
+      : m_buffer(buffer.GetBuffer()), m_id(buffer.GetBufferIdentifier()) {}
+  MemoryBufferRef(std::span<const uint8_t> buffer, std::string_view id)
+      : m_buffer(buffer), m_id(id) {}
+
+  std::span<const uint8_t> GetBuffer() const { return m_buffer; }
+
+  std::string_view GetBufferIdentifier() const { return m_id; }
+
+  const uint8_t* begin() const { return &*m_buffer.begin(); }
+  const uint8_t* end() const { return &*m_buffer.end(); }
+  size_t size() const { return m_buffer.size(); }
+};
+
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/PointerIntPair.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerIntPair.h
similarity index 88%
rename from wpiutil/src/main/native/include/wpi/PointerIntPair.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerIntPair.h
index e6a1212..34ff4e1 100644
--- a/wpiutil/src/main/native/include/wpi/PointerIntPair.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerIntPair.h
@@ -1,27 +1,29 @@
 //===- llvm/ADT/PointerIntPair.h - Pair for pointer and int -----*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the PointerIntPair class.
-//
+///
+/// \file
+/// This file defines the PointerIntPair class.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_POINTERINTPAIR_H
 #define WPIUTIL_WPI_POINTERINTPAIR_H
 
+#include "wpi/Compiler.h"
 #include "wpi/PointerLikeTypeTraits.h"
+#include "wpi/type_traits.h"
 #include <cassert>
 #include <cstdint>
 #include <limits>
 
 namespace wpi {
 
-template <typename T> struct DenseMapInfo;
+template <typename T, typename Enable> struct DenseMapInfo;
 template <typename PointerT, unsigned IntBits, typename PtrTraits>
 struct PointerIntPairInfo;
 
@@ -59,19 +61,19 @@
 
   IntType getInt() const { return (IntType)Info::getInt(Value); }
 
-  void setPointer(PointerTy PtrVal) {
+  void setPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updatePointer(Value, PtrVal);
   }
 
-  void setInt(IntType IntVal) {
+  void setInt(IntType IntVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updateInt(Value, static_cast<intptr_t>(IntVal));
   }
 
-  void initWithPointer(PointerTy PtrVal) {
+  void initWithPointer(PointerTy PtrVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updatePointer(0, PtrVal);
   }
 
-  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) {
+  void setPointerAndInt(PointerTy PtrVal, IntType IntVal) LLVM_LVALUE_FUNCTION {
     Value = Info::updateInt(Info::updatePointer(0, PtrVal),
                             static_cast<intptr_t>(IntVal));
   }
@@ -89,7 +91,7 @@
 
   void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
 
-  void setFromOpaqueValue(void *Val) {
+  void setFromOpaqueValue(void *Val) LLVM_LVALUE_FUNCTION {
     Value = reinterpret_cast<intptr_t>(Val);
   }
 
@@ -126,6 +128,7 @@
   }
 };
 
+
 template <typename PointerT, unsigned IntBits, typename PtrTraits>
 struct PointerIntPairInfo {
   static_assert(PtrTraits::NumLowBitsAvailable <
@@ -133,7 +136,7 @@
                 "cannot use a pointer type that has all bits free");
   static_assert(IntBits <= PtrTraits::NumLowBitsAvailable,
                 "PointerIntPair with integer size too large for pointer");
-  enum : uintptr_t {
+  enum MaskAndShiftConstants : uintptr_t {
     /// PointerBitMask - The bits that come from the pointer.
     PointerBitMask =
         ~(uintptr_t)(((intptr_t)1 << PtrTraits::NumLowBitsAvailable) - 1),
@@ -176,15 +179,9 @@
   }
 };
 
-template <typename T> struct isPodLike;
-template <typename PointerTy, unsigned IntBits, typename IntType>
-struct isPodLike<PointerIntPair<PointerTy, IntBits, IntType>> {
-  static const bool value = true;
-};
-
 // Provide specialization of DenseMapInfo for PointerIntPair.
 template <typename PointerTy, unsigned IntBits, typename IntType>
-struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
+struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>, void> {
   using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
 
   static Ty getEmptyKey() {
@@ -227,7 +224,8 @@
     return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
   }
 
-  enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
+  static constexpr int NumLowBitsAvailable =
+      PtrTraits::NumLowBitsAvailable - IntBits;
 };
 
 } // end namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/PointerLikeTypeTraits.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerLikeTypeTraits.h
similarity index 86%
rename from wpiutil/src/main/native/include/wpi/PointerLikeTypeTraits.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerLikeTypeTraits.h
index fa136e0..ffca61a 100644
--- a/wpiutil/src/main/native/include/wpi/PointerLikeTypeTraits.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerLikeTypeTraits.h
@@ -1,9 +1,8 @@
 //===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,8 +14,8 @@
 #ifndef WPIUTIL_WPI_POINTERLIKETYPETRAITS_H
 #define WPIUTIL_WPI_POINTERLIKETYPETRAITS_H
 
+#include <cassert>
 #include <cstdint>
-#include <cstdlib>
 #include <type_traits>
 
 namespace wpi {
@@ -38,8 +37,9 @@
 };
 
 // sizeof(T) is valid only for a complete T.
-template <typename T> struct HasPointerLikeTypeTraits<
-  T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
+template <typename T>
+struct HasPointerLikeTypeTraits<
+    T, decltype((sizeof(PointerLikeTypeTraits<T>) + sizeof(T)), void())> {
   static const bool value = true;
 };
 
@@ -57,7 +57,8 @@
   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
 
-  enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<alignof(T)>::value;
 };
 
 template <> struct PointerLikeTypeTraits<void *> {
@@ -71,7 +72,7 @@
   ///
   /// All clients should use assertions to do a run-time check to ensure that
   /// this is actually true.
-  enum { NumLowBitsAvailable = 2 };
+  static constexpr int NumLowBitsAvailable = 2;
 };
 
 // Provide PointerLikeTypeTraits for const things.
@@ -84,7 +85,7 @@
   static inline const T getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for const pointers.
@@ -97,7 +98,7 @@
   static inline const T *getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for uintptr_t.
@@ -109,7 +110,7 @@
     return reinterpret_cast<uintptr_t>(P);
   }
   // No bits are available!
-  enum { NumLowBitsAvailable = 0 };
+  static constexpr int NumLowBitsAvailable = 0;
 };
 
 /// Provide suitable custom traits struct for function pointers.
@@ -122,7 +123,8 @@
 /// potentially use alignment attributes on functions to satisfy that.
 template <int Alignment, typename FunctionPointerT>
 struct FunctionPointerLikeTypeTraits {
-  enum { NumLowBitsAvailable = detail::ConstantLog2<Alignment>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<Alignment>::value;
   static inline void *getAsVoidPointer(FunctionPointerT P) {
     assert((reinterpret_cast<uintptr_t>(P) &
             ~((uintptr_t)-1 << NumLowBitsAvailable)) == 0 &&
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerUnion.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerUnion.h
new file mode 100644
index 0000000..cc12bbc
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/PointerUnion.h
@@ -0,0 +1,295 @@
+//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the PointerUnion class, which is a discriminated union of
+/// pointer types.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_POINTERUNION_H
+#define WPIUTIL_WPI_POINTERUNION_H
+
+#include "wpi/DenseMapInfo.h"
+#include "wpi/PointerIntPair.h"
+#include "wpi/PointerLikeTypeTraits.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace wpi {
+
+namespace detail {
+template <typename T, typename... Us> struct TypesAreDistinct;
+template <typename T, typename... Us>
+struct TypesAreDistinct
+    : std::integral_constant<bool, !std::disjunction_v<std::is_same<T, Us>...> &&
+                                       TypesAreDistinct<Us...>::value> {};
+template <typename T> struct TypesAreDistinct<T> : std::true_type {};
+} // namespace detail
+
+/// Determine if all types in Ts are distinct.
+///
+/// Useful to statically assert when Ts is intended to describe a non-multi set
+/// of types.
+///
+/// Expensive (currently quadratic in sizeof(Ts...)), and so should only be
+/// asserted once per instantiation of a type which requires it.
+template <typename... Ts> struct TypesAreDistinct;
+template <> struct TypesAreDistinct<> : std::true_type {};
+template <typename... Ts>
+struct TypesAreDistinct
+    : std::integral_constant<bool, detail::TypesAreDistinct<Ts...>::value> {};
+
+/// Find the first index where a type appears in a list of types.
+///
+/// FirstIndexOfType<T, Us...>::value is the first index of T in Us.
+///
+/// Typically only meaningful when it is otherwise statically known that the
+/// type pack has no duplicate types. This should be guaranteed explicitly with
+/// static_assert(TypesAreDistinct<Us...>::value).
+///
+/// It is a compile-time error to instantiate when T is not present in Us, i.e.
+/// if is_one_of<T, Us...>::value is false.
+template <typename T, typename... Us> struct FirstIndexOfType;
+template <typename T, typename U, typename... Us>
+struct FirstIndexOfType<T, U, Us...>
+    : std::integral_constant<size_t, 1 + FirstIndexOfType<T, Us...>::value> {};
+template <typename T, typename... Us>
+struct FirstIndexOfType<T, T, Us...> : std::integral_constant<size_t, 0> {};
+
+/// Find the type at a given index in a list of types.
+///
+/// TypeAtIndex<I, Ts...> is the type at index I in Ts.
+template <size_t I, typename... Ts>
+using TypeAtIndex = std::tuple_element_t<I, std::tuple<Ts...>>;
+
+namespace pointer_union_detail {
+  /// Determine the number of bits required to store integers with values < n.
+  /// This is ceil(log2(n)).
+  constexpr int bitsRequired(unsigned n) {
+    return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
+  }
+
+  template <typename... Ts> constexpr int lowBitsAvailable() {
+    return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
+  }
+
+  /// Find the first type in a list of types.
+  template <typename T, typename...> struct GetFirstType {
+    using type = T;
+  };
+
+  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
+  /// for the template arguments.
+  template <typename ...PTs> class PointerUnionUIntTraits {
+  public:
+    static inline void *getAsVoidPointer(void *P) { return P; }
+    static inline void *getFromVoidPointer(void *P) { return P; }
+    static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
+  };
+
+  template <typename Derived, typename ValTy, int I, typename ...Types>
+  class PointerUnionMembers;
+
+  template <typename Derived, typename ValTy, int I>
+  class PointerUnionMembers<Derived, ValTy, I> {
+  protected:
+    ValTy Val;
+    PointerUnionMembers() = default;
+    PointerUnionMembers(ValTy Val) : Val(Val) {}
+
+    friend struct PointerLikeTypeTraits<Derived>;
+  };
+
+  template <typename Derived, typename ValTy, int I, typename Type,
+            typename ...Types>
+  class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
+      : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
+    using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
+  public:
+    using Base::Base;
+    PointerUnionMembers() = default;
+    PointerUnionMembers(Type V)
+        : Base(ValTy(const_cast<void *>(
+                         PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
+                     I)) {}
+
+    using Base::operator=;
+    Derived &operator=(Type V) {
+      this->Val = ValTy(
+          const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
+          I);
+      return static_cast<Derived &>(*this);
+    };
+  };
+}
+
+/// A discriminated union of two or more pointer types, with the discriminator
+/// in the low bit of the pointer.
+///
+/// This implementation is extremely efficient in space due to leveraging the
+/// low bits of the pointer, while exposing a natural and type-safe API.
+///
+/// Common use patterns would be something like this:
+///    PointerUnion<int*, float*> P;
+///    P = (int*)0;
+///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
+///    X = P.get<int*>();     // ok.
+///    Y = P.get<float*>();   // runtime assertion failure.
+///    Z = P.get<double*>();  // compile time failure.
+///    P = (float*)0;
+///    Y = P.get<float*>();   // ok.
+///    X = P.get<int*>();     // runtime assertion failure.
+///    PointerUnion<int*, int*> Q; // compile time failure.
+template <typename... PTs>
+class PointerUnion
+    : public pointer_union_detail::PointerUnionMembers<
+          PointerUnion<PTs...>,
+          PointerIntPair<
+              void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
+              pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
+          0, PTs...> {
+  static_assert(TypesAreDistinct<PTs...>::value,
+                "PointerUnion alternative types cannot be repeated");
+  // The first type is special because we want to directly cast a pointer to a
+  // default-initialized union to a pointer to the first type. But we don't
+  // want PointerUnion to be a 'template <typename First, typename ...Rest>'
+  // because it's much more convenient to have a name for the whole pack. So
+  // split off the first type here.
+  using First = TypeAtIndex<0, PTs...>;
+  using Base = typename PointerUnion::PointerUnionMembers;
+
+public:
+  PointerUnion() = default;
+
+  PointerUnion(std::nullptr_t) : PointerUnion() {}
+  using Base::Base;
+
+  /// Test if the pointer held in the union is null, regardless of
+  /// which type it is.
+  bool isNull() const { return !this->Val.getPointer(); }
+
+  explicit operator bool() const { return !isNull(); }
+
+  /// Test if the Union currently holds the type matching T.
+  template <typename T> bool is() const {
+    return this->Val.getInt() == FirstIndexOfType<T, PTs...>::value;
+  }
+
+  /// Returns the value of the specified pointer type.
+  ///
+  /// If the specified pointer type is incorrect, assert.
+  template <typename T> T get() const {
+    assert(is<T>() && "Invalid accessor called");
+    return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
+  }
+
+  /// Returns the current pointer if it is of the specified pointer type,
+  /// otherwise returns null.
+  template <typename T> T dyn_cast() const {
+    if (is<T>())
+      return get<T>();
+    return T();
+  }
+
+  /// If the union is set to the first pointer type get an address pointing to
+  /// it.
+  First const *getAddrOfPtr1() const {
+    return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
+  }
+
+  /// If the union is set to the first pointer type get an address pointing to
+  /// it.
+  First *getAddrOfPtr1() {
+    assert(is<First>() && "Val is not the first pointer");
+    assert(
+        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==
+            this->Val.getPointer() &&
+        "Can't get the address because PointerLikeTypeTraits changes the ptr");
+    return const_cast<First *>(
+        reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
+  }
+
+  /// Assignment from nullptr which just clears the union.
+  const PointerUnion &operator=(std::nullptr_t) {
+    this->Val.initWithPointer(nullptr);
+    return *this;
+  }
+
+  /// Assignment from elements of the union.
+  using Base::operator=;
+
+  void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
+  static inline PointerUnion getFromOpaqueValue(void *VP) {
+    PointerUnion V;
+    V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
+    return V;
+  }
+};
+
+template <typename ...PTs>
+bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
+  return lhs.getOpaqueValue() == rhs.getOpaqueValue();
+}
+
+template <typename ...PTs>
+bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
+  return lhs.getOpaqueValue() != rhs.getOpaqueValue();
+}
+
+template <typename ...PTs>
+bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
+  return lhs.getOpaqueValue() < rhs.getOpaqueValue();
+}
+
+// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
+// # low bits available = min(PT1bits,PT2bits)-1.
+template <typename ...PTs>
+struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
+  static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
+    return P.getOpaqueValue();
+  }
+
+  static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
+    return PointerUnion<PTs...>::getFromOpaqueValue(P);
+  }
+
+  // The number of bits available are the min of the pointer types minus the
+  // bits needed for the discriminator.
+  static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
+      PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
+};
+
+// Teach DenseMap how to use PointerUnions as keys.
+template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
+  using Union = PointerUnion<PTs...>;
+  using FirstInfo =
+      DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
+
+  static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
+
+  static inline Union getTombstoneKey() {
+    return Union(FirstInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const Union &UnionVal) {
+    intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
+    return DenseMapInfo<intptr_t>::getHashValue(key);
+  }
+
+  static bool isEqual(const Union &LHS, const Union &RHS) {
+    return LHS == RHS;
+  }
+};
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_POINTERUNION_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ReverseIteration.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ReverseIteration.h
new file mode 100644
index 0000000..f46d38d
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/ReverseIteration.h
@@ -0,0 +1,18 @@
+#ifndef WPIUTIL_WPI_REVERSEITERATION_H
+#define WPIUTIL_WPI_REVERSEITERATION_H
+
+#include "wpi/PointerLikeTypeTraits.h"
+
+namespace wpi {
+
+template<class T = void *>
+bool shouldReverseIterate() {
+#if LLVM_ENABLE_REVERSE_ITERATION
+  return detail::IsPointerLike<T>::value;
+#else
+  return false;
+#endif
+}
+
+}
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/STLForwardCompat.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/STLForwardCompat.h
new file mode 100644
index 0000000..7f8f068
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/STLForwardCompat.h
@@ -0,0 +1,83 @@
+//===- STLForwardCompat.h - Library features from future STLs ------C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains library features backported from future STL versions.
+///
+/// These should be replaced with their STL counterparts as the C++ version LLVM
+/// is compiled with is updated.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_STLFORWARDCOMPAT_H
+#define WPIUTIL_WPI_STLFORWARDCOMPAT_H
+
+#include <type_traits>
+
+namespace wpi {
+
+//===----------------------------------------------------------------------===//
+//     Features from C++17
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct negation // NOLINT(readability-identifier-naming)
+    : std::integral_constant<bool, !bool(T::value)> {};
+
+template <typename...>
+struct conjunction // NOLINT(readability-identifier-naming)
+    : std::true_type {};
+template <typename B1> struct conjunction<B1> : B1 {};
+template <typename B1, typename... Bn>
+struct conjunction<B1, Bn...>
+    : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
+
+template <typename...>
+struct disjunction // NOLINT(readability-identifier-naming)
+    : std::false_type {};
+template <typename B1> struct disjunction<B1> : B1 {};
+template <typename B1, typename... Bn>
+struct disjunction<B1, Bn...>
+    : std::conditional<bool(B1::value), B1, disjunction<Bn...>>::type {};
+
+struct in_place_t // NOLINT(readability-identifier-naming)
+{
+  explicit in_place_t() = default;
+};
+/// \warning This must not be odr-used, as it cannot be made \c inline in C++14.
+constexpr in_place_t in_place; // NOLINT(readability-identifier-naming)
+
+template <typename T>
+struct in_place_type_t // NOLINT(readability-identifier-naming)
+{
+  explicit in_place_type_t() = default;
+};
+
+template <std::size_t I>
+struct in_place_index_t // NOLINT(readability-identifier-naming)
+{
+  explicit in_place_index_t() = default;
+};
+
+//===----------------------------------------------------------------------===//
+//     Features from C++20
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct remove_cvref // NOLINT(readability-identifier-naming)
+{
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+template <typename T>
+using remove_cvref_t // NOLINT(readability-identifier-naming)
+    = typename wpi::remove_cvref<T>::type;
+
+} // namespace wpi
+
+#endif // WPIUTIL_WPI_STLFORWARDCOMPAT_H
diff --git a/wpiutil/src/main/native/include/wpi/SmallPtrSet.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallPtrSet.h
similarity index 83%
rename from wpiutil/src/main/native/include/wpi/SmallPtrSet.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallPtrSet.h
index 8669527..1ada1e0 100644
--- a/wpiutil/src/main/native/include/wpi/SmallPtrSet.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallPtrSet.h
@@ -1,26 +1,26 @@
 //===- llvm/ADT/SmallPtrSet.h - 'Normally small' pointer set ----*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the SmallPtrSet class.  See the doxygen comment for
-// SmallPtrSetImplBase for more details on the algorithm used.
+///
+/// \file
+/// This file defines the SmallPtrSet class.  See the doxygen comment for
+/// SmallPtrSetImplBase for more details on the algorithm used.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_SMALLPTRSET_H
 #define WPIUTIL_WPI_SMALLPTRSET_H
 
+#include "wpi/EpochTracker.h"
 #include "wpi/Compiler.h"
-#include "wpi/PointerLikeTypeTraits.h"
+#include "wpi/ReverseIteration.h"
 #include "wpi/type_traits.h"
 #include <cassert>
 #include <cstddef>
-#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
@@ -47,7 +47,7 @@
 /// (-2), to allow deletion.  The hash table is resized when the table is 3/4 or
 /// more.  When this happens, the table is doubled in size.
 ///
-class SmallPtrSetImplBase {
+class SmallPtrSetImplBase : public DebugEpochBase {
   friend class SmallPtrSetIteratorImpl;
 
 protected:
@@ -93,6 +93,7 @@
   size_type size() const { return NumNonEmpty - NumTombstones; }
 
   void clear() {
+    incrementEpoch();
     // If the capacity of the array is huge, and the # elements used is small,
     // shrink the array.
     if (!isSmall()) {
@@ -139,12 +140,14 @@
       if (LastTombstone != nullptr) {
         *LastTombstone = Ptr;
         --NumTombstones;
+        incrementEpoch();
         return std::make_pair(LastTombstone, true);
       }
 
       // Nope, there isn't.  If we stay small, just 'pushback' now.
       if (NumNonEmpty < CurArraySize) {
         SmallArray[NumNonEmpty++] = Ptr;
+        incrementEpoch();
         return std::make_pair(SmallArray + (NumNonEmpty - 1), true);
       }
       // Otherwise, hit the big set case, which will call grow.
@@ -224,6 +227,10 @@
 public:
   explicit SmallPtrSetIteratorImpl(const void *const *BP, const void*const *E)
     : Bucket(BP), End(E) {
+    if (shouldReverseIterate()) {
+      RetreatIfNotValid();
+      return;
+    }
     AdvanceIfNotValid();
   }
 
@@ -257,7 +264,8 @@
 
 /// SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
 template <typename PtrTy>
-class SmallPtrSetIterator : public SmallPtrSetIteratorImpl {
+class SmallPtrSetIterator : public SmallPtrSetIteratorImpl,
+                            DebugEpochBase::HandleBase {
   using PtrTraits = PointerLikeTypeTraits<PtrTy>;
 
 public:
@@ -267,17 +275,29 @@
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::forward_iterator_tag;
 
-  explicit SmallPtrSetIterator(const void *const *BP, const void *const *E)
-      : SmallPtrSetIteratorImpl(BP, E) {}
+  explicit SmallPtrSetIterator(const void *const *BP, const void *const *E,
+                               const DebugEpochBase &Epoch)
+      : SmallPtrSetIteratorImpl(BP, E), DebugEpochBase::HandleBase(&Epoch) {}
 
-  // Most methods provided by baseclass.
+  // Most methods are provided by the base class.
 
   const PtrTy operator*() const {
+    assert(isHandleInSync() && "invalid iterator access!");
+    if (shouldReverseIterate()) {
+      assert(Bucket > End);
+      return PtrTraits::getFromVoidPointer(const_cast<void *>(Bucket[-1]));
+    }
     assert(Bucket < End);
     return PtrTraits::getFromVoidPointer(const_cast<void*>(*Bucket));
   }
 
   inline SmallPtrSetIterator& operator++() {          // Preincrement
+    assert(isHandleInSync() && "invalid iterator access!");
+    if (shouldReverseIterate()) {
+      --Bucket;
+      RetreatIfNotValid();
+      return *this;
+    }
     ++Bucket;
     AdvanceIfNotValid();
     return *this;
@@ -327,14 +347,8 @@
   using ConstPtrTraits = PointerLikeTypeTraits<ConstPtrType>;
 
 protected:
-  // Constructors that forward to the base.
-  SmallPtrSetImpl(const void **SmallStorage, const SmallPtrSetImpl &that)
-      : SmallPtrSetImplBase(SmallStorage, that) {}
-  SmallPtrSetImpl(const void **SmallStorage, unsigned SmallSize,
-                  SmallPtrSetImpl &&that)
-      : SmallPtrSetImplBase(SmallStorage, SmallSize, std::move(that)) {}
-  explicit SmallPtrSetImpl(const void **SmallStorage, unsigned SmallSize)
-      : SmallPtrSetImplBase(SmallStorage, SmallSize) {}
+  // Forward constructors to the base.
+  using SmallPtrSetImplBase::SmallPtrSetImplBase;
 
 public:
   using iterator = SmallPtrSetIterator<PtrType>;
@@ -353,17 +367,28 @@
     return std::make_pair(makeIterator(p.first), p.second);
   }
 
+  /// Insert the given pointer with an iterator hint that is ignored. This is
+  /// identical to calling insert(Ptr), but allows SmallPtrSet to be used by
+  /// std::insert_iterator and std::inserter().
+  iterator insert(iterator, PtrType Ptr) {
+    return insert(Ptr).first;
+  }
+
   /// erase - If the set contains the specified pointer, remove it and return
   /// true, otherwise return false.
   bool erase(PtrType Ptr) {
     return erase_imp(PtrTraits::getAsVoidPointer(Ptr));
   }
-
   /// count - Return 1 if the specified pointer is in the set, 0 otherwise.
-  size_type count(ConstPtrType Ptr) const { return find(Ptr) != end() ? 1 : 0; }
+  size_type count(ConstPtrType Ptr) const {
+    return find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)) != EndPointer();
+  }
   iterator find(ConstPtrType Ptr) const {
     return makeIterator(find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)));
   }
+  bool contains(ConstPtrType Ptr) const {
+    return find_imp(ConstPtrTraits::getAsVoidPointer(Ptr)) != EndPointer();
+  }
 
   template <typename IterT>
   void insert(IterT I, IterT E) {
@@ -376,6 +401,8 @@
   }
 
   iterator begin() const {
+    if (shouldReverseIterate())
+      return makeIterator(EndPointer() - 1);
     return makeIterator(CurArray);
   }
   iterator end() const { return makeIterator(EndPointer()); }
@@ -383,10 +410,38 @@
 private:
   /// Create an iterator that dereferences to same place as the given pointer.
   iterator makeIterator(const void *const *P) const {
-    return iterator(P, EndPointer());
+    if (shouldReverseIterate())
+      return iterator(P == EndPointer() ? CurArray : P + 1, CurArray, *this);
+    return iterator(P, EndPointer(), *this);
   }
 };
 
+/// Equality comparison for SmallPtrSet.
+///
+/// Iterates over elements of LHS confirming that each value from LHS is also in
+/// RHS, and that no additional values are in RHS.
+template <typename PtrType>
+bool operator==(const SmallPtrSetImpl<PtrType> &LHS,
+                const SmallPtrSetImpl<PtrType> &RHS) {
+  if (LHS.size() != RHS.size())
+    return false;
+
+  for (const auto *KV : LHS)
+    if (!RHS.count(KV))
+      return false;
+
+  return true;
+}
+
+/// Inequality comparison for SmallPtrSet.
+///
+/// Equivalent to !(LHS == RHS).
+template <typename PtrType>
+bool operator!=(const SmallPtrSetImpl<PtrType> &LHS,
+                const SmallPtrSetImpl<PtrType> &RHS) {
+  return !(LHS == RHS);
+}
+
 /// SmallPtrSet - This class implements a set which is optimized for holding
 /// SmallSize or less elements.  This internally rounds up SmallSize to the next
 /// power of two if it is not already a power of two.  See the comments above
@@ -460,4 +515,4 @@
 
 } // end namespace std
 
-#endif // LLVM_ADT_SMALLPTRSET_H
+#endif // WPIUTIL_WPI_SMALLPTRSET_H
diff --git a/wpiutil/src/main/native/include/wpi/SmallSet.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallSet.h
similarity index 83%
rename from wpiutil/src/main/native/include/wpi/SmallSet.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallSet.h
index dca204e..7b1b283 100644
--- a/wpiutil/src/main/native/include/wpi/SmallSet.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallSet.h
@@ -1,14 +1,14 @@
 //===- llvm/ADT/SmallSet.h - 'Normally small' sets --------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the SmallSet class.
-//
+///
+/// \file
+/// This file defines the SmallSet class.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_SMALLSET_H
@@ -16,8 +16,8 @@
 
 #include "wpi/SmallPtrSet.h"
 #include "wpi/SmallVector.h"
-#include "wpi/Compiler.h"
 #include "wpi/iterator.h"
+#include "wpi/Compiler.h"
 #include "wpi/type_traits.h"
 #include <cstddef>
 #include <functional>
@@ -233,6 +233,13 @@
     return {Set.end()};
   }
 
+  /// Check if the SmallSet contains the given element.
+  bool contains(const T &V) const {
+    if (isSmall())
+      return vfind(V) != Vector.end();
+    return Set.find(V) != Set.end();
+  }
+
 private:
   bool isSmall() const { return Set.empty(); }
 
@@ -249,6 +256,31 @@
 template <typename PointeeType, unsigned N>
 class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
 
+/// Equality comparison for SmallSet.
+///
+/// Iterates over elements of LHS confirming that each element is also a member
+/// of RHS, and that RHS contains no additional values.
+/// Equivalent to N calls to RHS.count.
+/// For small-set mode amortized complexity is O(N^2)
+/// For large-set mode amortized complexity is linear, worst case is O(N^2) (if
+/// every hash collides).
+template <typename T, unsigned LN, unsigned RN, typename C>
+bool operator==(const SmallSet<T, LN, C> &LHS, const SmallSet<T, RN, C> &RHS) {
+  if (LHS.size() != RHS.size())
+    return false;
+
+  // All elements in LHS must also be in RHS
+  return std::all_of(LHS.begin(), LHS.end(), [&RHS](const T &E) { return RHS.count(E); });
+}
+
+/// Inequality comparison for SmallSet.
+///
+/// Equivalent to !(LHS == RHS). See operator== for performance notes.
+template <typename T, unsigned LN, unsigned RN, typename C>
+bool operator!=(const SmallSet<T, LN, C> &LHS, const SmallSet<T, RN, C> &RHS) {
+  return !(LHS == RHS);
+}
+
 } // end namespace wpi
 
-#endif // LLVM_ADT_SMALLSET_H
+#endif // WPIUTIL_WPI_SMALLSET_H
diff --git a/wpiutil/src/main/native/include/wpi/SmallString.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallString.h
similarity index 71%
rename from wpiutil/src/main/native/include/wpi/SmallString.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallString.h
index da4b2e4..4a53fee 100644
--- a/wpiutil/src/main/native/include/wpi/SmallString.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallString.h
@@ -1,14 +1,14 @@
 //===- llvm/ADT/SmallString.h - 'Normally small' strings --------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the SmallString class.
-//
+///
+/// \file
+/// This file defines the SmallString class.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_SMALLSTRING_H
@@ -16,6 +16,7 @@
 
 #include "wpi/SmallVector.h"
 #include <cstddef>
+#include <string>
 #include <string_view>
 
 namespace wpi {
@@ -29,66 +30,58 @@
   SmallString() = default;
 
   /// Initialize from a std::string_view.
-  SmallString(std::string_view S)
-    : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
+  SmallString(std::string_view S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
+
+  /// Initialize by concatenating a list of std::string_views.
+  SmallString(std::initializer_list<std::string_view> Refs)
+      : SmallVector<char, InternalLen>() {
+    this->append(Refs);
+  }
 
   /// Initialize with a range.
   template<typename ItTy>
   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
 
-  // Note that in order to add new overloads for append & assign, we have to
-  // duplicate the inherited versions so as not to inadvertently hide them.
-
   /// @}
   /// @name String Assignment
   /// @{
 
-  /// Assign from a repeated element.
-  void assign(size_t NumElts, char Elt) {
-    this->SmallVectorImpl<char>::assign(NumElts, Elt);
-  }
-
-  /// Assign from an iterator pair.
-  template<typename in_iter>
-  void assign(in_iter S, in_iter E) {
-    this->clear();
-    SmallVectorImpl<char>::append(S, E);
-  }
+  using SmallVector<char, InternalLen>::assign;
 
   /// Assign from a std::string_view.
   void assign(std::string_view RHS) {
-    this->clear();
-    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
+    SmallVectorImpl<char>::assign(RHS.begin(), RHS.end());
   }
 
-  /// Assign from a SmallVector.
-  void assign(const SmallVectorImpl<char> &RHS) {
+  /// Assign from a list of std::string_views.
+  void assign(std::initializer_list<std::string_view> Refs) {
     this->clear();
-    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
+    append(Refs);
   }
 
   /// @}
   /// @name String Concatenation
   /// @{
 
-  /// Append from an iterator pair.
-  template<typename in_iter>
-  void append(in_iter S, in_iter E) {
-    SmallVectorImpl<char>::append(S, E);
-  }
-
-  void append(size_t NumInputs, char Elt) {
-    SmallVectorImpl<char>::append(NumInputs, Elt);
-  }
+  using SmallVector<char, InternalLen>::append;
 
   /// Append from a std::string_view.
   void append(std::string_view RHS) {
     SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
   }
 
-  /// Append from a SmallVector.
-  void append(const SmallVectorImpl<char> &RHS) {
-    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
+  /// Append from a list of std::string_views.
+  void append(std::initializer_list<std::string_view> Refs) {
+    size_t CurrentSize = this->size();
+    size_t SizeNeeded = CurrentSize;
+    for (std::string_view Ref : Refs)
+      SizeNeeded += Ref.size();
+    this->resize_for_overwrite(SizeNeeded);
+    for (std::string_view Ref : Refs) {
+      std::copy(Ref.begin(), Ref.end(), this->begin() + CurrentSize);
+      CurrentSize += Ref.size();
+    }
+    assert(CurrentSize == this->size());
   }
 
   /// @}
@@ -185,10 +178,7 @@
   // Extra methods.
 
   /// Explicit conversion to std::string_view.
-  std::string_view str() const { return {this->begin(), this->size()}; }
-
-  /// Explicit conversion to std::string.
-  std::string string() const { return {this->begin(), this->size()}; }
+  std::string_view str() const { return std::string_view(this->begin(), this->size()); }
 
   // TODO: Make this const, if it's safe...
   const char* c_str() {
@@ -200,13 +190,14 @@
   /// Implicit conversion to std::string_view.
   operator std::string_view() const { return str(); }
 
-  /// Implicit conversion to std::string.
-  operator std::string() const { return string(); }
+  explicit operator std::string() const {
+    return std::string(this->data(), this->size());
+  }
 
   // Extra operators.
-  const SmallString &operator=(std::string_view RHS) {
-    this->clear();
-    return *this += RHS;
+  SmallString &operator=(std::string_view RHS) {
+    this->assign(RHS);
+    return *this;
   }
 
   SmallString &operator+=(std::string_view RHS) {
@@ -221,4 +212,4 @@
 
 } // end namespace wpi
 
-#endif // LLVM_ADT_SMALLSTRING_H
+#endif // WPIUTIL_WPI_SMALLSTRING_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVector.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVector.h
new file mode 100644
index 0000000..134ce67
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVector.h
@@ -0,0 +1,1312 @@
+//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// /file
+/// This file defines the SmallVector class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_SMALLVECTOR_H
+#define WPIUTIL_WPI_SMALLVECTOR_H
+
+// This file uses std::memcpy() to copy std::pair<unsigned int, unsigned int>.
+// That type is POD, but the standard doesn't guarantee that. GCC doesn't treat
+// the type as POD so it throws a warning. We want to consider this a warning
+// instead of an error.
+#if __GNUC__ >= 8
+#pragma GCC diagnostic warning "-Wclass-memaccess"
+#endif
+
+#include "wpi/Compiler.h"
+#include "wpi/type_traits.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace wpi {
+
+template <typename IteratorT> class iterator_range;
+
+/// This is all the stuff common to all SmallVectors.
+///
+/// The template parameter specifies the type which should be used to hold the
+/// Size and Capacity of the SmallVector, so it can be adjusted.
+/// Using 32 bit size is desirable to shrink the size of the SmallVector.
+/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
+/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
+/// buffering bitcode output - which can exceed 4GB.
+class SmallVectorBase {
+protected:
+  void *BeginX;
+  unsigned Size = 0, Capacity;
+
+  /// The maximum value of the Size_T used.
+  static constexpr size_t SizeTypeMax() {
+    return (std::numeric_limits<unsigned>::max)();
+  }
+
+  SmallVectorBase() = delete;
+  SmallVectorBase(void *FirstEl, size_t TotalCapacity)
+      : BeginX(FirstEl), Capacity(static_cast<unsigned>(TotalCapacity)) {}
+
+  /// This is a helper for \a grow() that's out of line to reduce code
+  /// duplication.  This function will report a fatal error if it can't grow at
+  /// least to \p MinSize.
+  void *mallocForGrow(size_t MinSize, size_t TSize, size_t &NewCapacity);
+
+  /// This is an implementation of the grow() method which only works
+  /// on POD-like data types and is out of line to reduce code duplication.
+  /// This function will report a fatal error if it cannot increase capacity.
+  void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);
+
+public:
+  size_t size() const { return Size; }
+  size_t capacity() const { return Capacity; }
+
+  LLVM_NODISCARD bool empty() const { return !Size; }
+
+protected:
+  /// Set the array size to \p N, which the current array must have enough
+  /// capacity for.
+  ///
+  /// This does not construct or destroy any elements in the vector.
+  void set_size(size_t N) {
+    assert(N <= capacity());
+    Size = static_cast<unsigned>(N);
+  }
+};
+
+/// Figure out the offset of the first element.
+template <class T, typename = void> struct SmallVectorAlignmentAndSize {
+  alignas(SmallVectorBase) char Base[sizeof(
+      SmallVectorBase)];
+  alignas(T) char FirstEl[sizeof(T)];
+};
+
+/// This is the part of SmallVectorTemplateBase which does not depend on whether
+/// the type T is a POD. The extra dummy template argument is used by ArrayRef
+/// to avoid unnecessarily requiring T to be complete.
+template <typename T, typename = void>
+class SmallVectorTemplateCommon
+    : public SmallVectorBase {
+  using Base = SmallVectorBase;
+
+  /// Find the address of the first element.  For this pointer math to be valid
+  /// with small-size of 0 for T with lots of alignment, it's important that
+  /// SmallVectorStorage is properly-aligned even for small-size of 0.
+  void *getFirstEl() const {
+    return const_cast<void *>(reinterpret_cast<const void *>(
+        reinterpret_cast<const char *>(this) +
+        offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)));
+  }
+  // Space after 'FirstEl' is clobbered, do not add any instance vars after it.
+
+protected:
+  SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}
+
+  void grow_pod(size_t MinSize, size_t TSize) {
+    Base::grow_pod(getFirstEl(), MinSize, TSize);
+  }
+
+  /// Return true if this is a smallvector which has not had dynamic
+  /// memory allocated for it.
+  bool isSmall() const { return this->BeginX == getFirstEl(); }
+
+  /// Put this vector in a state of being small.
+  void resetToSmall() {
+    this->BeginX = getFirstEl();
+    this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
+  }
+
+  /// Return true if V is an internal reference to the given range.
+  bool isReferenceToRange(const void *V, const void *First, const void *Last) const {
+    // Use std::less to avoid UB.
+    std::less<> LessThan;
+    return !LessThan(V, First) && LessThan(V, Last);
+  }
+
+  /// Return true if V is an internal reference to this vector.
+  bool isReferenceToStorage(const void *V) const {
+    return isReferenceToRange(V, this->begin(), this->end());
+  }
+
+  /// Return true if First and Last form a valid (possibly empty) range in this
+  /// vector's storage.
+  bool isRangeInStorage(const void *First, const void *Last) const {
+    // Use std::less to avoid UB.
+    std::less<> LessThan;
+    return !LessThan(First, this->begin()) && !LessThan(Last, First) &&
+           !LessThan(this->end(), Last);
+  }
+
+  /// Return true unless Elt will be invalidated by resizing the vector to
+  /// NewSize.
+  bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
+    // Past the end.
+    if (LLVM_LIKELY(!isReferenceToStorage(Elt)))
+      return true;
+
+    // Return false if Elt will be destroyed by shrinking.
+    if (NewSize <= this->size())
+      return Elt < this->begin() + NewSize;
+
+    // Return false if we need to grow.
+    return NewSize <= this->capacity();
+  }
+
+  /// Check whether Elt will be invalidated by resizing the vector to NewSize.
+  void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
+    assert(isSafeToReferenceAfterResize(Elt, NewSize) &&
+           "Attempting to reference an element of the vector in an operation "
+           "that invalidates it");
+  }
+
+  /// Check whether Elt will be invalidated by increasing the size of the
+  /// vector by N.
+  void assertSafeToAdd(const void *Elt, size_t N = 1) {
+    this->assertSafeToReferenceAfterResize(Elt, this->size() + N);
+  }
+
+  /// Check whether any part of the range will be invalidated by clearing.
+  void assertSafeToReferenceAfterClear(const T *From, const T *To) {
+    if (From == To)
+      return;
+    this->assertSafeToReferenceAfterResize(From, 0);
+    this->assertSafeToReferenceAfterResize(To - 1, 0);
+  }
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
+  void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
+
+  /// Check whether any part of the range will be invalidated by growing.
+  void assertSafeToAddRange(const T *From, const T *To) {
+    if (From == To)
+      return;
+    this->assertSafeToAdd(From, To - From);
+    this->assertSafeToAdd(To - 1, To - From);
+  }
+  template <
+      class ItTy,
+      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
+                       bool> = false>
+  void assertSafeToAddRange(ItTy, ItTy) {}
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  template <class U>
+  static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
+                                                   size_t N) {
+    size_t NewSize = This->size() + N;
+    if (LLVM_LIKELY(NewSize <= This->capacity()))
+      return &Elt;
+
+    bool ReferencesStorage = false;
+    int64_t Index = -1;
+    if (!U::TakesParamByValue) {
+      if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
+        ReferencesStorage = true;
+        Index = &Elt - This->begin();
+      }
+    }
+    This->grow(NewSize);
+    return ReferencesStorage ? This->begin() + Index : &Elt;
+  }
+
+public:
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using value_type = T;
+  using iterator = T *;
+  using const_iterator = const T *;
+
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+
+  using reference = T &;
+  using const_reference = const T &;
+  using pointer = T *;
+  using const_pointer = const T *;
+
+  using Base::capacity;
+  using Base::empty;
+  using Base::size;
+
+  // forward iterator creation methods.
+  iterator begin() { return (iterator)this->BeginX; }
+  const_iterator begin() const { return (const_iterator)this->BeginX; }
+  iterator end() { return begin() + size(); }
+  const_iterator end() const { return begin() + size(); }
+
+  // reverse iterator creation methods.
+  reverse_iterator rbegin()            { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
+  reverse_iterator rend()              { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
+
+  size_type size_in_bytes() const { return size() * sizeof(T); }
+  size_type max_size() const {
+    return (std::min)(this->SizeTypeMax(), size_type(-1) / sizeof(T));
+  }
+
+  size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
+
+  /// Return a pointer to the vector's buffer, even if empty().
+  pointer data() { return pointer(begin()); }
+  /// Return a pointer to the vector's buffer, even if empty().
+  const_pointer data() const { return const_pointer(begin()); }
+
+  reference operator[](size_type idx) {
+    assert(idx < size());
+    return begin()[idx];
+  }
+  const_reference operator[](size_type idx) const {
+    assert(idx < size());
+    return begin()[idx];
+  }
+
+  reference front() {
+    assert(!empty());
+    return begin()[0];
+  }
+  const_reference front() const {
+    assert(!empty());
+    return begin()[0];
+  }
+
+  reference back() {
+    assert(!empty());
+    return end()[-1];
+  }
+  const_reference back() const {
+    assert(!empty());
+    return end()[-1];
+  }
+};
+
+/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
+/// method implementations that are designed to work with non-trivial T's.
+///
+/// We approximate is_trivially_copyable with trivial move/copy construction and
+/// trivial destruction. While the standard doesn't specify that you're allowed
+/// copy these types with memcpy, there is no way for the type to observe this.
+/// This catches the important case of std::pair<POD, POD>, which is not
+/// trivially assignable.
+template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
+                             (is_trivially_move_constructible<T>::value) &&
+                             std::is_trivially_destructible<T>::value>
+class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
+  friend class SmallVectorTemplateCommon<T>;
+
+protected:
+  static constexpr bool TakesParamByValue = false;
+  using ValueParamT = const T &;
+
+  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
+
+  static void destroy_range(T *S, T *E) {
+    while (S != E) {
+      --E;
+      E->~T();
+    }
+  }
+
+  /// Move the range [I, E) into the uninitialized memory starting with "Dest",
+  /// constructing elements as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
+    std::uninitialized_copy(std::make_move_iterator(I),
+                            std::make_move_iterator(E), Dest);
+  }
+
+  /// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
+  /// constructing elements as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
+    std::uninitialized_copy(I, E, Dest);
+  }
+
+  /// Grow the allocated memory (without initializing new elements), doubling
+  /// the size of the allocated memory. Guarantees space for at least one more
+  /// element, or MinSize more elements if specified.
+  void grow(size_t MinSize = 0);
+
+  /// Create a new allocation big enough for \p MinSize and pass back its size
+  /// in \p NewCapacity. This is the first section of \a grow().
+  T *mallocForGrow(size_t MinSize, size_t &NewCapacity) {
+    return static_cast<T *>(
+        SmallVectorBase::mallocForGrow(
+            MinSize, sizeof(T), NewCapacity));
+  }
+
+  /// Move existing elements over to the new allocation \p NewElts, the middle
+  /// section of \a grow().
+  void moveElementsForGrow(T *NewElts);
+
+  /// Transfer ownership of the allocation, finishing up \a grow().
+  void takeAllocationForGrow(T *NewElts, size_t NewCapacity);
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
+    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
+  }
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
+    return const_cast<T *>(
+        this->reserveForParamAndGetAddressImpl(this, Elt, N));
+  }
+
+  static T &&forward_value_param(T &&V) { return std::move(V); }
+  static const T &forward_value_param(const T &V) { return V; }
+
+  void growAndAssign(size_t NumElts, const T &Elt) {
+    // Grow manually in case Elt is an internal reference.
+    size_t NewCapacity;
+    T *NewElts = mallocForGrow(NumElts, NewCapacity);
+    std::uninitialized_fill_n(NewElts, NumElts, Elt);
+    this->destroy_range(this->begin(), this->end());
+    takeAllocationForGrow(NewElts, NewCapacity);
+    this->set_size(NumElts);
+  }
+
+  template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
+    // Grow manually in case one of Args is an internal reference.
+    size_t NewCapacity;
+    T *NewElts = mallocForGrow(0, NewCapacity);
+    ::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
+    moveElementsForGrow(NewElts);
+    takeAllocationForGrow(NewElts, NewCapacity);
+    this->set_size(this->size() + 1);
+    return this->back();
+  }
+
+public:
+  void push_back(const T &Elt) {
+    const T *EltPtr = reserveForParamAndGetAddress(Elt);
+    ::new ((void *)this->end()) T(*EltPtr);
+    this->set_size(this->size() + 1);
+  }
+
+  void push_back(T &&Elt) {
+    T *EltPtr = reserveForParamAndGetAddress(Elt);
+    ::new ((void *)this->end()) T(::std::move(*EltPtr));
+    this->set_size(this->size() + 1);
+  }
+
+  void pop_back() {
+    this->set_size(this->size() - 1);
+    this->end()->~T();
+  }
+};
+
+// Define this out-of-line to dissuade the C++ compiler from inlining it.
+template <typename T, bool TriviallyCopyable>
+void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
+  size_t NewCapacity;
+  T *NewElts = mallocForGrow(MinSize, NewCapacity);
+  moveElementsForGrow(NewElts);
+  takeAllocationForGrow(NewElts, NewCapacity);
+}
+
+// Define this out-of-line to dissuade the C++ compiler from inlining it.
+template <typename T, bool TriviallyCopyable>
+void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
+    T *NewElts) {
+  // Move the elements over.
+  this->uninitialized_move(this->begin(), this->end(), NewElts);
+
+  // Destroy the original elements.
+  destroy_range(this->begin(), this->end());
+}
+
+// Define this out-of-line to dissuade the C++ compiler from inlining it.
+template <typename T, bool TriviallyCopyable>
+void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
+    T *NewElts, size_t NewCapacity) {
+  // If this wasn't grown from the inline copy, deallocate the old space.
+  if (!this->isSmall())
+    free(this->begin());
+
+  this->BeginX = NewElts;
+  this->Capacity = static_cast<unsigned>(NewCapacity);
+}
+
+/// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
+/// method implementations that are designed to work with trivially copyable
+/// T's. This allows using memcpy in place of copy/move construction and
+/// skipping destruction.
+template <typename T>
+class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
+  friend class SmallVectorTemplateCommon<T>;
+
+protected:
+  /// True if it's cheap enough to take parameters by value. Doing so avoids
+  /// overhead related to mitigations for reference invalidation.
+  static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);
+
+  /// Either const T& or T, depending on whether it's cheap enough to take
+  /// parameters by value.
+  using ValueParamT =
+      typename std::conditional<TakesParamByValue, T, const T &>::type;
+
+  SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
+
+  // No need to do a destroy loop for POD's.
+  static void destroy_range(T *, T *) {}
+
+  /// Move the range [I, E) onto the uninitialized memory
+  /// starting with "Dest", constructing elements into it as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_move(It1 I, It1 E, It2 Dest) {
+    // Just do a copy.
+    uninitialized_copy(I, E, Dest);
+  }
+
+  /// Copy the range [I, E) onto the uninitialized memory
+  /// starting with "Dest", constructing elements into it as needed.
+  template<typename It1, typename It2>
+  static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
+    // Arbitrary iterator types; just use the basic implementation.
+    std::uninitialized_copy(I, E, Dest);
+  }
+
+  /// Copy the range [I, E) onto the uninitialized memory
+  /// starting with "Dest", constructing elements into it as needed.
+  template <typename T1, typename T2>
+  static void uninitialized_copy(
+      T1 *I, T1 *E, T2 *Dest,
+      std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
+                                    T2>::value> * = nullptr) {
+    // Use memcpy for PODs iterated by pointers (which includes SmallVector
+    // iterators): std::uninitialized_copy optimizes to memmove, but we can
+    // use memcpy here. Note that I and E are iterators and thus might be
+    // invalid for memcpy if they are equal.
+    if (I != E)
+      memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
+  }
+
+  /// Double the size of the allocated memory, guaranteeing space for at
+  /// least one more element or MinSize if specified.
+  void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
+    return this->reserveForParamAndGetAddressImpl(this, Elt, N);
+  }
+
+  /// Reserve enough space to add one element, and return the updated element
+  /// pointer in case it was a reference to the storage.
+  T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
+    return const_cast<T *>(
+        this->reserveForParamAndGetAddressImpl(this, Elt, N));
+  }
+
+  /// Copy \p V or return a reference, depending on \a ValueParamT.
+  static ValueParamT forward_value_param(ValueParamT V) { return V; }
+
+  void growAndAssign(size_t NumElts, T Elt) {
+    // Elt has been copied in case it's an internal reference, side-stepping
+    // reference invalidation problems without losing the realloc optimization.
+    this->set_size(0);
+    this->grow(NumElts);
+    std::uninitialized_fill_n(this->begin(), NumElts, Elt);
+    this->set_size(NumElts);
+  }
+
+  template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
+    // Use push_back with a copy in case Args has an internal reference,
+    // side-stepping reference invalidation problems without losing the realloc
+    // optimization.
+    push_back(T(std::forward<ArgTypes>(Args)...));
+    return this->back();
+  }
+
+public:
+  void push_back(ValueParamT Elt) {
+    const T *EltPtr = reserveForParamAndGetAddress(Elt);
+    memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
+    this->set_size(this->size() + 1);
+  }
+
+  void pop_back() { this->set_size(this->size() - 1); }
+};
+
+/// This class consists of common code factored out of the SmallVector class to
+/// reduce code duplication based on the SmallVector 'N' template parameter.
+template <typename T>
+class SmallVectorImpl : public SmallVectorTemplateBase<T> {
+  using SuperClass = SmallVectorTemplateBase<T>;
+
+public:
+  using iterator = typename SuperClass::iterator;
+  using const_iterator = typename SuperClass::const_iterator;
+  using reference = typename SuperClass::reference;
+  using size_type = typename SuperClass::size_type;
+
+protected:
+  using SmallVectorTemplateBase<T>::TakesParamByValue;
+  using ValueParamT = typename SuperClass::ValueParamT;
+
+  // Default ctor - Initialize to empty.
+  explicit SmallVectorImpl(unsigned N)
+      : SmallVectorTemplateBase<T>(N) {}
+
+  void assignRemote(SmallVectorImpl &&RHS) {
+    this->destroy_range(this->begin(), this->end());
+    if (!this->isSmall())
+      free(this->begin());
+    this->BeginX = RHS.BeginX;
+    this->Size = RHS.Size;
+    this->Capacity = RHS.Capacity;
+    RHS.resetToSmall();
+  }
+
+public:
+  SmallVectorImpl(const SmallVectorImpl &) = delete;
+
+  ~SmallVectorImpl() {
+    // Subclass has already destructed this vector's elements.
+    // If this wasn't grown from the inline copy, deallocate the old space.
+    if (!this->isSmall())
+      free(this->begin());
+  }
+
+  void clear() {
+    this->destroy_range(this->begin(), this->end());
+    this->Size = 0;
+  }
+
+private:
+  // Make set_size() private to avoid misuse in subclasses.
+  using SuperClass::set_size;
+
+  template <bool ForOverwrite> void resizeImpl(size_type N) {
+    if (N == this->size())
+      return;
+
+    if (N < this->size()) {
+      this->truncate(N);
+      return;
+    }
+
+    this->reserve(N);
+    for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
+      if (ForOverwrite)
+        new (&*I) T;
+      else
+        new (&*I) T();
+    this->set_size(N);
+  }
+
+public:
+  void resize(size_type N) { resizeImpl<false>(N); }
+
+  /// Like resize, but \ref T is POD, the new values won't be initialized.
+  void resize_for_overwrite(size_type N) { resizeImpl<true>(N); }
+
+  /// Like resize, but requires that \p N is less than \a size().
+  void truncate(size_type N) {
+    assert(this->size() >= N && "Cannot increase size with truncate");
+    this->destroy_range(this->begin() + N, this->end());
+    this->set_size(N);
+  }
+
+  void resize(size_type N, ValueParamT NV) {
+    if (N == this->size())
+      return;
+
+    if (N < this->size()) {
+      this->truncate(N);
+      return;
+    }
+
+    // N > this->size(). Defer to append.
+    this->append(N - this->size(), NV);
+  }
+
+  void reserve(size_type N) {
+    if (this->capacity() < N)
+      this->grow(N);
+  }
+
+  void pop_back_n(size_type NumItems) {
+    assert(this->size() >= NumItems);
+    truncate(this->size() - NumItems);
+  }
+
+  LLVM_NODISCARD T pop_back_val() {
+    T Result = ::std::move(this->back());
+    this->pop_back();
+    return Result;
+  }
+
+  void swap(SmallVectorImpl &RHS);
+
+  /// Add the specified range to the end of the SmallVector.
+  template <typename in_iter,
+            typename = std::enable_if_t<std::is_convertible<
+                typename std::iterator_traits<in_iter>::iterator_category,
+                std::input_iterator_tag>::value>>
+  void append(in_iter in_start, in_iter in_end) {
+    this->assertSafeToAddRange(in_start, in_end);
+    size_type NumInputs = std::distance(in_start, in_end);
+    this->reserve(this->size() + NumInputs);
+    this->uninitialized_copy(in_start, in_end, this->end());
+    this->set_size(this->size() + NumInputs);
+  }
+
+  /// Append \p NumInputs copies of \p Elt to the end.
+  void append(size_type NumInputs, ValueParamT Elt) {
+    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
+    std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
+    this->set_size(this->size() + NumInputs);
+  }
+
+  void append(std::initializer_list<T> IL) {
+    append(IL.begin(), IL.end());
+  }
+
+  void append(const SmallVectorImpl &RHS) { append(RHS.begin(), RHS.end()); }
+
+  void assign(size_type NumElts, ValueParamT Elt) {
+    // Note that Elt could be an internal reference.
+    if (NumElts > this->capacity()) {
+      this->growAndAssign(NumElts, Elt);
+      return;
+    }
+
+    // Assign over existing elements.
+    std::fill_n(this->begin(), (std::min)(NumElts, this->size()), Elt);
+    if (NumElts > this->size())
+      std::uninitialized_fill_n(this->end(), NumElts - this->size(), Elt);
+    else if (NumElts < this->size())
+      this->destroy_range(this->begin() + NumElts, this->end());
+    this->set_size(NumElts);
+  }
+
+  // FIXME: Consider assigning over existing elements, rather than clearing &
+  // re-initializing them - for all assign(...) variants.
+
+  template <typename in_iter,
+            typename = std::enable_if_t<std::is_convertible<
+                typename std::iterator_traits<in_iter>::iterator_category,
+                std::input_iterator_tag>::value>>
+  void assign(in_iter in_start, in_iter in_end) {
+    this->assertSafeToReferenceAfterClear(in_start, in_end);
+    clear();
+    append(in_start, in_end);
+  }
+
+  void assign(std::initializer_list<T> IL) {
+    clear();
+    append(IL);
+  }
+
+  void assign(const SmallVectorImpl &RHS) { assign(RHS.begin(), RHS.end()); }
+
+  iterator erase(const_iterator CI) {
+    // Just cast away constness because this is a non-const member function.
+    iterator I = const_cast<iterator>(CI);
+
+    assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.");
+
+    iterator N = I;
+    // Shift all elts down one.
+    std::move(I+1, this->end(), I);
+    // Drop the last elt.
+    this->pop_back();
+    return(N);
+  }
+
+  iterator erase(const_iterator CS, const_iterator CE) {
+    // Just cast away constness because this is a non-const member function.
+    iterator S = const_cast<iterator>(CS);
+    iterator E = const_cast<iterator>(CE);
+
+    assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.");
+
+    iterator N = S;
+    // Shift all elts down.
+    iterator I = std::move(E, this->end(), S);
+    // Drop the last elts.
+    this->destroy_range(I, this->end());
+    this->set_size(I - this->begin());
+    return(N);
+  }
+
+private:
+  template <class ArgType> iterator insert_one_impl(iterator I, ArgType &&Elt) {
+    // Callers ensure that ArgType is derived from T.
+    static_assert(
+        std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
+                     T>::value,
+        "ArgType must be derived from T!");
+
+    if (I == this->end()) {  // Important special case for empty vector.
+      this->push_back(::std::forward<ArgType>(Elt));
+      return this->end()-1;
+    }
+
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
+
+    // Grow if necessary.
+    size_t Index = I - this->begin();
+    std::remove_reference_t<ArgType> *EltPtr =
+        this->reserveForParamAndGetAddress(Elt);
+    I = this->begin() + Index;
+
+    ::new ((void*) this->end()) T(::std::move(this->back()));
+    // Push everything else over.
+    std::move_backward(I, this->end()-1, this->end());
+    this->set_size(this->size() + 1);
+
+    // If we just moved the element we're inserting, be sure to update
+    // the reference (never happens if TakesParamByValue).
+    static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
+                  "ArgType must be 'T' when taking by value!");
+    if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
+      ++EltPtr;
+
+    *I = ::std::forward<ArgType>(*EltPtr);
+    return I;
+  }
+
+public:
+  iterator insert(iterator I, T &&Elt) {
+    return insert_one_impl(I, this->forward_value_param(std::move(Elt)));
+  }
+
+  iterator insert(iterator I, const T &Elt) {
+    return insert_one_impl(I, this->forward_value_param(Elt));
+  }
+
+  iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
+    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
+    size_t InsertElt = I - this->begin();
+
+    if (I == this->end()) {  // Important special case for empty vector.
+      append(NumToInsert, Elt);
+      return this->begin()+InsertElt;
+    }
+
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
+
+    // Ensure there is enough space, and get the (maybe updated) address of
+    // Elt.
+    const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);
+
+    // Uninvalidate the iterator.
+    I = this->begin()+InsertElt;
+
+    // If there are more elements between the insertion point and the end of the
+    // range than there are being inserted, we can use a simple approach to
+    // insertion.  Since we already reserved space, we know that this won't
+    // reallocate the vector.
+    if (size_t(this->end()-I) >= NumToInsert) {
+      T *OldEnd = this->end();
+      append(std::move_iterator<iterator>(this->end() - NumToInsert),
+             std::move_iterator<iterator>(this->end()));
+
+      // Copy the existing elements that get replaced.
+      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
+
+      // If we just moved the element we're inserting, be sure to update
+      // the reference (never happens if TakesParamByValue).
+      if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
+        EltPtr += NumToInsert;
+
+      std::fill_n(I, NumToInsert, *EltPtr);
+      return I;
+    }
+
+    // Otherwise, we're inserting more elements than exist already, and we're
+    // not inserting at the end.
+
+    // Move over the elements that we're about to overwrite.
+    T *OldEnd = this->end();
+    this->set_size(this->size() + NumToInsert);
+    size_t NumOverwritten = OldEnd-I;
+    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
+
+    // If we just moved the element we're inserting, be sure to update
+    // the reference (never happens if TakesParamByValue).
+    if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
+      EltPtr += NumToInsert;
+
+    // Replace the overwritten part.
+    std::fill_n(I, NumOverwritten, *EltPtr);
+
+    // Insert the non-overwritten middle part.
+    std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
+    return I;
+  }
+
+  template <typename ItTy,
+            typename = std::enable_if_t<std::is_convertible<
+                typename std::iterator_traits<ItTy>::iterator_category,
+                std::input_iterator_tag>::value>>
+  iterator insert(iterator I, ItTy From, ItTy To) {
+    // Convert iterator to elt# to avoid invalidating iterator when we reserve()
+    size_t InsertElt = I - this->begin();
+
+    if (I == this->end()) {  // Important special case for empty vector.
+      append(From, To);
+      return this->begin()+InsertElt;
+    }
+
+    assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
+
+    // Check that the reserve that follows doesn't invalidate the iterators.
+    this->assertSafeToAddRange(From, To);
+
+    size_t NumToInsert = std::distance(From, To);
+
+    // Ensure there is enough space.
+    reserve(this->size() + NumToInsert);
+
+    // Uninvalidate the iterator.
+    I = this->begin()+InsertElt;
+
+    // If there are more elements between the insertion point and the end of the
+    // range than there are being inserted, we can use a simple approach to
+    // insertion.  Since we already reserved space, we know that this won't
+    // reallocate the vector.
+    if (size_t(this->end()-I) >= NumToInsert) {
+      T *OldEnd = this->end();
+      append(std::move_iterator<iterator>(this->end() - NumToInsert),
+             std::move_iterator<iterator>(this->end()));
+
+      // Copy the existing elements that get replaced.
+      std::move_backward(I, OldEnd-NumToInsert, OldEnd);
+
+      std::copy(From, To, I);
+      return I;
+    }
+
+    // Otherwise, we're inserting more elements than exist already, and we're
+    // not inserting at the end.
+
+    // Move over the elements that we're about to overwrite.
+    T *OldEnd = this->end();
+    this->set_size(this->size() + NumToInsert);
+    size_t NumOverwritten = OldEnd-I;
+    this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
+
+    // Replace the overwritten part.
+    for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
+      *J = *From;
+      ++J; ++From;
+    }
+
+    // Insert the non-overwritten middle part.
+    this->uninitialized_copy(From, To, OldEnd);
+    return I;
+  }
+
+  void insert(iterator I, std::initializer_list<T> IL) {
+    insert(I, IL.begin(), IL.end());
+  }
+
+  template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
+    if (LLVM_UNLIKELY(this->size() >= this->capacity()))
+      return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
+
+    ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
+    this->set_size(this->size() + 1);
+    return this->back();
+  }
+
+  SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
+
+  SmallVectorImpl &operator=(SmallVectorImpl &&RHS);
+
+  bool operator==(const SmallVectorImpl &RHS) const {
+    if (this->size() != RHS.size()) return false;
+    return std::equal(this->begin(), this->end(), RHS.begin());
+  }
+  bool operator!=(const SmallVectorImpl &RHS) const {
+    return !(*this == RHS);
+  }
+
+  bool operator<(const SmallVectorImpl &RHS) const {
+    return std::lexicographical_compare(this->begin(), this->end(),
+                                        RHS.begin(), RHS.end());
+  }
+};
+
+template <typename T>
+void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
+  if (this == &RHS) return;
+
+  // We can only avoid copying elements if neither vector is small.
+  if (!this->isSmall() && !RHS.isSmall()) {
+    std::swap(this->BeginX, RHS.BeginX);
+    std::swap(this->Size, RHS.Size);
+    std::swap(this->Capacity, RHS.Capacity);
+    return;
+  }
+  this->reserve(RHS.size());
+  RHS.reserve(this->size());
+
+  // Swap the shared elements.
+  size_t NumShared = this->size();
+  if (NumShared > RHS.size()) NumShared = RHS.size();
+  for (size_type i = 0; i != NumShared; ++i)
+    std::swap((*this)[i], RHS[i]);
+
+  // Copy over the extra elts.
+  if (this->size() > RHS.size()) {
+    size_t EltDiff = this->size() - RHS.size();
+    this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
+    RHS.set_size(RHS.size() + EltDiff);
+    this->destroy_range(this->begin()+NumShared, this->end());
+    this->set_size(NumShared);
+  } else if (RHS.size() > this->size()) {
+    size_t EltDiff = RHS.size() - this->size();
+    this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
+    this->set_size(this->size() + EltDiff);
+    this->destroy_range(RHS.begin()+NumShared, RHS.end());
+    RHS.set_size(NumShared);
+  }
+}
+
+template <typename T>
+SmallVectorImpl<T> &SmallVectorImpl<T>::
+  operator=(const SmallVectorImpl<T> &RHS) {
+  // Avoid self-assignment.
+  if (this == &RHS) return *this;
+
+  // If we already have sufficient space, assign the common elements, then
+  // destroy any excess.
+  size_t RHSSize = RHS.size();
+  size_t CurSize = this->size();
+  if (CurSize >= RHSSize) {
+    // Assign common elements.
+    iterator NewEnd;
+    if (RHSSize)
+      NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
+    else
+      NewEnd = this->begin();
+
+    // Destroy excess elements.
+    this->destroy_range(NewEnd, this->end());
+
+    // Trim.
+    this->set_size(RHSSize);
+    return *this;
+  }
+
+  // If we have to grow to have enough elements, destroy the current elements.
+  // This allows us to avoid copying them during the grow.
+  // FIXME: don't do this if they're efficiently moveable.
+  if (this->capacity() < RHSSize) {
+    // Destroy current elements.
+    this->clear();
+    CurSize = 0;
+    this->grow(RHSSize);
+  } else if (CurSize) {
+    // Otherwise, use assignment for the already-constructed elements.
+    std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
+  }
+
+  // Copy construct the new elements in place.
+  this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
+                           this->begin()+CurSize);
+
+  // Set end.
+  this->set_size(RHSSize);
+  return *this;
+}
+
+template <typename T>
+SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
+  // Avoid self-assignment.
+  if (this == &RHS) return *this;
+
+  // If the RHS isn't small, clear this vector and then steal its buffer.
+  if (!RHS.isSmall()) {
+    this->assignRemote(std::move(RHS));
+    return *this;
+  }
+
+  // If we already have sufficient space, assign the common elements, then
+  // destroy any excess.
+  size_t RHSSize = RHS.size();
+  size_t CurSize = this->size();
+  if (CurSize >= RHSSize) {
+    // Assign common elements.
+    iterator NewEnd = this->begin();
+    if (RHSSize)
+      NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
+
+    // Destroy excess elements and trim the bounds.
+    this->destroy_range(NewEnd, this->end());
+    this->set_size(RHSSize);
+
+    // Clear the RHS.
+    RHS.clear();
+
+    return *this;
+  }
+
+  // If we have to grow to have enough elements, destroy the current elements.
+  // This allows us to avoid copying them during the grow.
+  // FIXME: this may not actually make any sense if we can efficiently move
+  // elements.
+  if (this->capacity() < RHSSize) {
+    // Destroy current elements.
+    this->clear();
+    CurSize = 0;
+    this->grow(RHSSize);
+  } else if (CurSize) {
+    // Otherwise, use assignment for the already-constructed elements.
+    std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
+  }
+
+  // Move-construct the new elements in place.
+  this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
+                           this->begin()+CurSize);
+
+  // Set end.
+  this->set_size(RHSSize);
+
+  RHS.clear();
+  return *this;
+}
+
+/// Storage for the SmallVector elements.  This is specialized for the N=0 case
+/// to avoid allocating unnecessary storage.
+template <typename T, unsigned N>
+struct SmallVectorStorage {
+  alignas(T) char InlineElts[N * sizeof(T)];
+};
+
+/// We need the storage to be properly aligned even for small-size of 0 so that
+/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
+/// well-defined.
+template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
+
+/// Forward declaration of SmallVector so that
+/// calculateSmallVectorDefaultInlinedElements can reference
+/// `sizeof(SmallVector<T, 0>)`.
+template <typename T, unsigned N> class LLVM_GSL_OWNER SmallVector;
+
+/// Helper class for calculating the default number of inline elements for
+/// `SmallVector<T>`.
+///
+/// This should be migrated to a constexpr function when our minimum
+/// compiler support is enough for multi-statement constexpr functions.
+template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
+  // Parameter controlling the default number of inlined elements
+  // for `SmallVector<T>`.
+  //
+  // The default number of inlined elements ensures that
+  // 1. There is at least one inlined element.
+  // 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
+  // it contradicts 1.
+  static constexpr size_t kPreferredSmallVectorSizeof = 64;
+
+  // static_assert that sizeof(T) is not "too big".
+  //
+  // Because our policy guarantees at least one inlined element, it is possible
+  // for an arbitrarily large inlined element to allocate an arbitrarily large
+  // amount of inline storage. We generally consider it an antipattern for a
+  // SmallVector to allocate an excessive amount of inline storage, so we want
+  // to call attention to these cases and make sure that users are making an
+  // intentional decision if they request a lot of inline storage.
+  //
+  // We want this assertion to trigger in pathological cases, but otherwise
+  // not be too easy to hit. To accomplish that, the cutoff is actually somewhat
+  // larger than kPreferredSmallVectorSizeof (otherwise,
+  // `SmallVector<SmallVector<T>>` would be one easy way to trip it, and that
+  // pattern seems useful in practice).
+  //
+  // One wrinkle is that this assertion is in theory non-portable, since
+  // sizeof(T) is in general platform-dependent. However, we don't expect this
+  // to be much of an issue, because most LLVM development happens on 64-bit
+  // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
+  // 32-bit hosts, dodging the issue. The reverse situation, where development
+  // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
+  // 64-bit host, is expected to be very rare.
+  static_assert(
+      sizeof(T) <= 256,
+      "You are trying to use a default number of inlined elements for "
+      "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
+      "explicit number of inlined elements with `SmallVector<T, N>` to make "
+      "sure you really want that much inline storage.");
+
+  // Discount the size of the header itself when calculating the maximum inline
+  // bytes.
+  static constexpr size_t PreferredInlineBytes =
+      kPreferredSmallVectorSizeof - sizeof(SmallVector<T, 0>);
+  static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
+  static constexpr size_t value =
+      NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
+};
+
+/// This is a 'vector' (really, a variable-sized array), optimized
+/// for the case when the array is small.  It contains some number of elements
+/// in-place, which allows it to avoid heap allocation when the actual number of
+/// elements is below that threshold.  This allows normal "small" cases to be
+/// fast without losing generality for large inputs.
+///
+/// \note
+/// In the absence of a well-motivated choice for the number of inlined
+/// elements \p N, it is recommended to use \c SmallVector<T> (that is,
+/// omitting the \p N). This will choose a default number of inlined elements
+/// reasonable for allocation on the stack (for example, trying to keep \c
+/// sizeof(SmallVector<T>) around 64 bytes).
+///
+/// \warning This does not attempt to be exception safe.
+///
+/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
+template <typename T,
+          unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
+class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
+                                   SmallVectorStorage<T, N> {
+public:
+  SmallVector() : SmallVectorImpl<T>(N) {}
+
+  ~SmallVector() {
+    // Destroy the constructed elements in the vector.
+    this->destroy_range(this->begin(), this->end());
+  }
+
+  explicit SmallVector(size_t Size, const T &Value = T())
+    : SmallVectorImpl<T>(N) {
+    this->assign(Size, Value);
+  }
+
+  template <typename ItTy,
+            typename = std::enable_if_t<std::is_convertible<
+                typename std::iterator_traits<ItTy>::iterator_category,
+                std::input_iterator_tag>::value>>
+  SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
+    this->append(S, E);
+  }
+
+  template <typename RangeTy>
+  explicit SmallVector(const iterator_range<RangeTy> &R)
+      : SmallVectorImpl<T>(N) {
+    this->append(R.begin(), R.end());
+  }
+
+  SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
+    this->assign(IL);
+  }
+
+  SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
+    if (!RHS.empty())
+      SmallVectorImpl<T>::operator=(RHS);
+  }
+
+  SmallVector &operator=(const SmallVector &RHS) {
+    SmallVectorImpl<T>::operator=(RHS);
+    return *this;
+  }
+
+  SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
+    if (!RHS.empty())
+      SmallVectorImpl<T>::operator=(::std::move(RHS));
+  }
+
+  SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
+    if (!RHS.empty())
+      SmallVectorImpl<T>::operator=(::std::move(RHS));
+  }
+
+  SmallVector &operator=(SmallVector &&RHS) {
+    if (N) {
+      SmallVectorImpl<T>::operator=(::std::move(RHS));
+      return *this;
+    }
+    // SmallVectorImpl<T>::operator= does not leverage N==0. Optimize the
+    // case.
+    if (this == &RHS)
+      return *this;
+    if (RHS.empty()) {
+      this->destroy_range(this->begin(), this->end());
+      this->Size = 0;
+    } else {
+      this->assignRemote(std::move(RHS));
+    }
+    return *this;
+  }
+
+  SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
+    SmallVectorImpl<T>::operator=(::std::move(RHS));
+    return *this;
+  }
+
+  SmallVector &operator=(std::initializer_list<T> IL) {
+    this->assign(IL);
+    return *this;
+  }
+};
+
+template <typename T, unsigned N>
+inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
+  return X.capacity_in_bytes();
+}
+
+template <typename RangeType>
+using ValueTypeFromRangeType =
+    typename std::remove_const<typename std::remove_reference<
+        decltype(*std::begin(std::declval<RangeType &>()))>::type>::type;
+
+/// Given a range of type R, iterate the entire range and return a
+/// SmallVector with elements of the vector.  This is useful, for example,
+/// when you want to iterate a range and then sort the results.
+template <unsigned Size, typename R>
+SmallVector<ValueTypeFromRangeType<R>, Size> to_vector(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+template <typename R>
+SmallVector<ValueTypeFromRangeType<R>,
+            CalculateSmallVectorDefaultInlinedElements<
+                ValueTypeFromRangeType<R>>::value>
+to_vector(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+
+} // end namespace wpi
+
+namespace std {
+
+  /// Implement std::swap in terms of SmallVector swap.
+  template<typename T>
+  inline void
+  swap(wpi::SmallVectorImpl<T> &LHS, wpi::SmallVectorImpl<T> &RHS) {
+    LHS.swap(RHS);
+  }
+
+  /// Implement std::swap in terms of SmallVector swap.
+  template<typename T, unsigned N>
+  inline void
+  swap(wpi::SmallVector<T, N> &LHS, wpi::SmallVector<T, N> &RHS) {
+    LHS.swap(RHS);
+  }
+
+} // end namespace std
+
+#endif // WPIUTIL_WPI_SMALLVECTOR_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVectorMemoryBuffer.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVectorMemoryBuffer.h
new file mode 100644
index 0000000..6173714
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SmallVectorMemoryBuffer.h
@@ -0,0 +1,63 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+//===- SmallVectorMemoryBuffer.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares a wrapper class to hold the memory into which an
+// object will be generated.
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <utility>
+
+#include "wpi/MemoryBuffer.h"
+#include "wpi/SmallVector.h"
+#include "wpi/raw_ostream.h"
+
+namespace wpi {
+
+/// SmallVector-backed MemoryBuffer instance.
+///
+/// This class enables efficient construction of MemoryBuffers from SmallVector
+/// instances.
+class SmallVectorMemoryBuffer : public MemoryBuffer {
+ public:
+  /// Construct an SmallVectorMemoryBuffer from the given SmallVector
+  /// r-value.
+  SmallVectorMemoryBuffer(SmallVectorImpl<uint8_t>&& sv)  // NOLINT
+      : m_sv(std::move(sv)), m_bufferName("<in-memory object>") {
+    Init(this->m_sv.begin(), this->m_sv.end());
+  }
+
+  /// Construct a named SmallVectorMemoryBuffer from the given
+  /// SmallVector r-value and StringRef.
+  SmallVectorMemoryBuffer(SmallVectorImpl<uint8_t>&& sv, std::string_view name)
+      : m_sv(std::move(sv)), m_bufferName(name) {
+    Init(this->m_sv.begin(), this->m_sv.end());
+  }
+
+  // Key function.
+  ~SmallVectorMemoryBuffer() override;
+
+  std::string_view GetBufferIdentifier() const override { return m_bufferName; }
+
+  BufferKind GetBufferKind() const override { return MemoryBuffer_Malloc; }
+
+ private:
+  SmallVector<uint8_t, 0> m_sv;
+  std::string m_bufferName;
+};
+
+}  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/StringExtras.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringExtras.h
similarity index 97%
rename from wpiutil/src/main/native/include/wpi/StringExtras.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringExtras.h
index 9e70f52..75c637b 100644
--- a/wpiutil/src/main/native/include/wpi/StringExtras.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringExtras.h
@@ -709,4 +709,16 @@
 std::optional<long double> parse_float<long double>(
     std::string_view str) noexcept;
 
+/**
+ * Unescapes a C-style string (reverse operation to raw_ostream::write_escaped).
+ * Scans through @p str until either the end is reached or an unescaped double
+ * quote character is found.
+ *
+ * @param str input string
+ * @param buf buffer for unescaped characters
+ * @return pair of the unescaped string and any remaining input
+ */
+std::pair<std::string_view, std::string_view> UnescapeCString(
+    std::string_view str, SmallVectorImpl<char>& buf);
+
 }  // namespace wpi
diff --git a/wpiutil/src/main/native/include/wpi/StringMap.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMap.h
similarity index 73%
rename from wpiutil/src/main/native/include/wpi/StringMap.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMap.h
index dac2f20..c7da670 100644
--- a/wpiutil/src/main/native/include/wpi/StringMap.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMap.h
@@ -1,51 +1,35 @@
 //===- StringMap.h - String Hash table map interface ------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
-// This file defines the StringMap class.
-//
+///
+/// \file
+/// This file defines the StringMap class.
+///
 //===----------------------------------------------------------------------===//
 
 #ifndef WPIUTIL_WPI_STRINGMAP_H
 #define WPIUTIL_WPI_STRINGMAP_H
 
+#include "wpi/StringMapEntry.h"
+#include "wpi/iterator.h"
+#include "wpi/AllocatorBase.h"
+#include "wpi/MemAlloc.h"
 #include "wpi/SmallVector.h"
 #include "wpi/iterator.h"
 #include "wpi/iterator_range.h"
-#include "wpi/MemAlloc.h"
 #include "wpi/PointerLikeTypeTraits.h"
-#include "wpi/ErrorHandling.h"
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
 #include <initializer_list>
 #include <iterator>
-#include <string_view>
-#include <utility>
 
 namespace wpi {
 
-template<typename ValueTy> class StringMapConstIterator;
-template<typename ValueTy> class StringMapIterator;
-template<typename ValueTy> class StringMapKeyIterator;
-template<typename ValueTy> class StringMapEntry;
-
-/// StringMapEntryBase - Shared base class of StringMapEntry instances.
-class StringMapEntryBase {
-  size_t StrLen;
-
-public:
-  explicit StringMapEntryBase(size_t Len) : StrLen(Len) {}
-
-  size_t getKeyLength() const { return StrLen; }
-};
+template <typename ValueTy> class StringMapConstIterator;
+template <typename ValueTy> class StringMapIterator;
+template <typename ValueTy> class StringMapKeyIterator;
 
 /// StringMapImpl - This is the base class of StringMap that is shared among
 /// all of its instantiations.
@@ -61,8 +45,7 @@
   unsigned ItemSize;
 
 protected:
-  explicit StringMapImpl(unsigned itemSize)
-      : ItemSize(itemSize) {}
+  explicit StringMapImpl(unsigned itemSize) : ItemSize(itemSize) {}
   StringMapImpl(StringMapImpl &&RHS) noexcept
       : TheTable(RHS.TheTable), NumBuckets(RHS.NumBuckets),
         NumItems(RHS.NumItems), NumTombstones(RHS.NumTombstones),
@@ -101,10 +84,12 @@
   void init(unsigned Size);
 
 public:
+  static constexpr uintptr_t TombstoneIntVal =
+      static_cast<uintptr_t>(-1)
+      << PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
+
   static StringMapEntryBase *getTombstoneVal() {
-    uintptr_t Val = static_cast<uintptr_t>(-1);
-    Val <<= PointerLikeTypeTraits<StringMapEntryBase *>::NumLowBitsAvailable;
-    return reinterpret_cast<StringMapEntryBase *>(Val);
+    return reinterpret_cast<StringMapEntryBase *>(TombstoneIntVal);
   }
 
   unsigned getNumBuckets() const { return NumBuckets; }
@@ -121,108 +106,41 @@
   }
 };
 
-/// StringMapEntry - This is used to represent one value that is inserted into
-/// a StringMap.  It contains the Value itself and the key: the string length
-/// and data.
-template<typename ValueTy>
-class StringMapEntry : public StringMapEntryBase {
-public:
-  ValueTy second;
-
-  explicit StringMapEntry(size_t strLen)
-    : StringMapEntryBase(strLen), second() {}
-  template <typename... InitTy>
-  StringMapEntry(size_t strLen, InitTy &&... InitVals)
-      : StringMapEntryBase(strLen), second(std::forward<InitTy>(InitVals)...) {}
-  StringMapEntry(StringMapEntry &E) = delete;
-
-  std::string_view getKey() const {
-    return {getKeyData(), getKeyLength()};
-  }
-
-  const ValueTy &getValue() const { return second; }
-  ValueTy &getValue() { return second; }
-
-  void setValue(const ValueTy &V) { second = V; }
-
-  /// getKeyData - Return the start of the string data that is the key for this
-  /// value.  The string data is always stored immediately after the
-  /// StringMapEntry object.
-  const char *getKeyData() const {return reinterpret_cast<const char*>(this+1);}
-
-  std::string_view first() const { return {getKeyData(), getKeyLength()}; }
-
-  /// Create a StringMapEntry for the specified key construct the value using
-  /// \p InitiVals.
-  template <typename... InitTy>
-  static StringMapEntry *Create(std::string_view Key, InitTy &&... InitVals) {
-    size_t KeyLength = Key.size();
-
-    // Allocate a new item with space for the string at the end and a null
-    // terminator.
-    size_t AllocSize = sizeof(StringMapEntry) + KeyLength + 1;
-
-    StringMapEntry *NewItem =
-      static_cast<StringMapEntry*>(safe_malloc(AllocSize));
-
-    // Construct the value.
-    new (NewItem) StringMapEntry(KeyLength, std::forward<InitTy>(InitVals)...);
-
-    // Copy the string information.
-    char *StrBuffer = const_cast<char*>(NewItem->getKeyData());
-    if (KeyLength > 0)
-      memcpy(StrBuffer, Key.data(), KeyLength);
-    StrBuffer[KeyLength] = 0;  // Null terminate for convenience of clients.
-    return NewItem;
-  }
-
-  static StringMapEntry *Create(std::string_view Key) {
-    return Create(Key, ValueTy());
-  }
-
-  /// GetStringMapEntryFromKeyData - Given key data that is known to be embedded
-  /// into a StringMapEntry, return the StringMapEntry itself.
-  static StringMapEntry &GetStringMapEntryFromKeyData(const char *KeyData) {
-    char *Ptr = const_cast<char*>(KeyData) - sizeof(StringMapEntry<ValueTy>);
-    return *reinterpret_cast<StringMapEntry*>(Ptr);
-  }
-
-  /// Destroy - Destroy this StringMapEntry, releasing memory back to the
-  /// specified allocator.
-  void Destroy() {
-    // Free memory referenced by the item.
-    this->~StringMapEntry();
-    std::free(static_cast<void *>(this));
-  }
-};
-
-
 /// StringMap - This is an unconventional map that is specialized for handling
 /// keys that are "strings", which are basically ranges of bytes. This does some
 /// funky memory allocation and hashing things to make it extremely efficient,
 /// storing the string data *after* the value in the map.
-template<typename ValueTy>
+template <typename ValueTy, typename AllocatorTy = MallocAllocator>
 class StringMap : public StringMapImpl {
+  AllocatorTy Allocator;
+
 public:
   using MapEntryTy = StringMapEntry<ValueTy>;
 
   StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
 
   explicit StringMap(unsigned InitialSize)
-    : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
+      : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
+
+  explicit StringMap(AllocatorTy A)
+      : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))), Allocator(A) {
+  }
+
+  StringMap(unsigned InitialSize, AllocatorTy A)
+      : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))),
+        Allocator(A) {}
 
   StringMap(std::initializer_list<std::pair<std::string_view, ValueTy>> List)
       : StringMapImpl(List.size(), static_cast<unsigned>(sizeof(MapEntryTy))) {
-    for (const auto &P : List) {
-      insert(P);
-    }
+    insert(List);
   }
 
   StringMap(StringMap &&RHS)
-      : StringMapImpl(std::move(RHS)) {}
+      : StringMapImpl(std::move(RHS)), Allocator(std::move(RHS.Allocator)) {}
 
-  StringMap(const StringMap &RHS) :
-    StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {
+  StringMap(const StringMap &RHS)
+      : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))),
+        Allocator(RHS.Allocator) {
     if (RHS.empty())
       return;
 
@@ -242,7 +160,7 @@
       }
 
       TheTable[I] = MapEntryTy::Create(
-          static_cast<MapEntryTy *>(Bucket)->getKey(),
+          static_cast<MapEntryTy *>(Bucket)->getKey(), Allocator,
           static_cast<MapEntryTy *>(Bucket)->getValue());
       HashTable[I] = RHSHashTable[I];
     }
@@ -257,6 +175,7 @@
 
   StringMap &operator=(StringMap RHS) {
     StringMapImpl::swap(RHS);
+    std::swap(Allocator, RHS.Allocator);
     return *this;
   }
 
@@ -268,14 +187,17 @@
       for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
         StringMapEntryBase *Bucket = TheTable[I];
         if (Bucket && Bucket != getTombstoneVal()) {
-          static_cast<MapEntryTy*>(Bucket)->Destroy();
+          static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
         }
       }
     }
     free(TheTable);
   }
 
-  using key_type = const char*;
+  AllocatorTy &getAllocator() { return Allocator; }
+  const AllocatorTy &getAllocator() const { return Allocator; }
+
+  using key_type = const char *;
   using mapped_type = ValueTy;
   using value_type = StringMapEntry<ValueTy>;
   using size_type = size_t;
@@ -283,17 +205,13 @@
   using const_iterator = StringMapConstIterator<ValueTy>;
   using iterator = StringMapIterator<ValueTy>;
 
-  iterator begin() {
-    return iterator(TheTable, NumBuckets == 0);
-  }
-  iterator end() {
-    return iterator(TheTable+NumBuckets, true);
-  }
+  iterator begin() { return iterator(TheTable, NumBuckets == 0); }
+  iterator end() { return iterator(TheTable + NumBuckets, true); }
   const_iterator begin() const {
     return const_iterator(TheTable, NumBuckets == 0);
   }
   const_iterator end() const {
-    return const_iterator(TheTable+NumBuckets, true);
+    return const_iterator(TheTable + NumBuckets, true);
   }
 
   iterator_range<StringMapKeyIterator<ValueTy>> keys() const {
@@ -303,14 +221,16 @@
 
   iterator find(std::string_view Key) {
     int Bucket = FindKey(Key);
-    if (Bucket == -1) return end();
-    return iterator(TheTable+Bucket, true);
+    if (Bucket == -1)
+      return end();
+    return iterator(TheTable + Bucket, true);
   }
 
   const_iterator find(std::string_view Key) const {
     int Bucket = FindKey(Key);
-    if (Bucket == -1) return end();
-    return const_iterator(TheTable+Bucket, true);
+    if (Bucket == -1)
+      return end();
+    return const_iterator(TheTable + Bucket, true);
   }
 
   /// lookup - Return the entry for the specified key, or a default
@@ -327,10 +247,33 @@
   ValueTy &operator[](std::string_view Key) { return try_emplace(Key).first->second; }
 
   /// count - Return 1 if the element is in the map, 0 otherwise.
-  size_type count(std::string_view Key) const {
-    return find(Key) == end() ? 0 : 1;
+  size_type count(std::string_view Key) const { return find(Key) == end() ? 0 : 1; }
+
+  template <typename InputTy>
+  size_type count(const StringMapEntry<InputTy> &MapEntry) const {
+    return count(MapEntry.getKey());
   }
 
+  /// equal - check whether both of the containers are equal.
+  bool operator==(const StringMap &RHS) const {
+    if (size() != RHS.size())
+      return false;
+
+    for (const auto &KeyValue : *this) {
+      auto FindInRHS = RHS.find(KeyValue.getKey());
+
+      if (FindInRHS == RHS.end())
+        return false;
+
+      if (!(KeyValue.getValue() == FindInRHS->getValue()))
+        return false;
+    }
+
+    return true;
+  }
+
+  bool operator!=(const StringMap &RHS) const { return !(*this == RHS); }
+
   /// insert - Insert the specified key/value pair into the map.  If the key
   /// already exists in the map, return false and ignore the request, otherwise
   /// insert it and return true.
@@ -338,7 +281,7 @@
     unsigned BucketNo = LookupBucketFor(KeyValue->getKey());
     StringMapEntryBase *&Bucket = TheTable[BucketNo];
     if (Bucket && Bucket != getTombstoneVal())
-      return false;  // Already exists in map.
+      return false; // Already exists in map.
 
     if (Bucket == getTombstoneVal())
       --NumTombstones;
@@ -358,6 +301,31 @@
     return try_emplace(KV.first, std::move(KV.second));
   }
 
+  /// Inserts elements from range [first, last). If multiple elements in the
+  /// range have keys that compare equivalent, it is unspecified which element
+  /// is inserted .
+  template <typename InputIt> void insert(InputIt First, InputIt Last) {
+    for (InputIt It = First; It != Last; ++It)
+      insert(*It);
+  }
+
+  ///  Inserts elements from initializer list ilist. If multiple elements in
+  /// the range have keys that compare equivalent, it is unspecified which
+  /// element is inserted
+  void insert(std::initializer_list<std::pair<std::string_view, ValueTy>> List) {
+    insert(List.begin(), List.end());
+  }
+
+  /// Inserts an element or assigns to the current element if the key already
+  /// exists. The return type is the same as try_emplace.
+  template <typename V>
+  std::pair<iterator, bool> insert_or_assign(std::string_view Key, V &&Val) {
+    auto Ret = try_emplace(Key, std::forward<V>(Val));
+    if (!Ret.second)
+      Ret.first->second = std::forward<V>(Val);
+    return Ret;
+  }
+
   /// Emplace a new element for the specified key into the map if the key isn't
   /// already in the map. The bool component of the returned pair is true
   /// if and only if the insertion takes place, and the iterator component of
@@ -372,7 +340,7 @@
 
     if (Bucket == getTombstoneVal())
       --NumTombstones;
-    Bucket = MapEntryTy::Create(Key, std::forward<ArgsTy>(Args)...);
+    Bucket = MapEntryTy::Create(Key, Allocator, std::forward<ArgsTy>(Args)...);
     ++NumItems;
     assert(NumItems + NumTombstones <= NumBuckets);
 
@@ -382,14 +350,15 @@
 
   // clear - Empties out the StringMap
   void clear() {
-    if (empty()) return;
+    if (empty())
+      return;
 
     // Zap all values, resetting the keys back to non-present (not tombstone),
     // which is safe because we're removing all elements.
     for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
       StringMapEntryBase *&Bucket = TheTable[I];
       if (Bucket && Bucket != getTombstoneVal()) {
-        static_cast<MapEntryTy*>(Bucket)->Destroy();
+        static_cast<MapEntryTy *>(Bucket)->Destroy(Allocator);
       }
       Bucket = nullptr;
     }
@@ -400,19 +369,18 @@
 
   /// remove - Remove the specified key/value pair from the map, but do not
   /// erase it.  This aborts if the key is not in the map.
-  void remove(MapEntryTy *KeyValue) {
-    RemoveKey(KeyValue);
-  }
+  void remove(MapEntryTy *KeyValue) { RemoveKey(KeyValue); }
 
   void erase(iterator I) {
     MapEntryTy &V = *I;
     remove(&V);
-    V.Destroy();
+    V.Destroy(Allocator);
   }
 
   bool erase(std::string_view Key) {
     iterator I = find(Key);
-    if (I == end()) return false;
+    if (I == end())
+      return false;
     erase(I);
     return true;
   }
@@ -431,7 +399,8 @@
   explicit StringMapIterBase(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
       : Ptr(Bucket) {
-    if (!NoAdvance) AdvancePastEmptyBuckets();
+    if (!NoAdvance)
+      AdvancePastEmptyBuckets();
   }
 
   DerivedTy &operator=(const DerivedTy &Other) {
@@ -439,13 +408,9 @@
     return static_cast<DerivedTy &>(*this);
   }
 
-#if __cplusplus < 202002L
-  bool operator==(const DerivedTy &RHS) const { return Ptr == RHS.Ptr; }
-#else
   friend bool operator==(const DerivedTy &LHS, const DerivedTy &RHS) {
     return LHS.Ptr == RHS.Ptr;
   }
-#endif
 
   DerivedTy &operator++() { // Preincrement
     ++Ptr;
@@ -490,15 +455,13 @@
                                  const StringMapEntry<ValueTy>>;
 
 public:
-  using value_type = const StringMapEntry<ValueTy>;
-
   StringMapConstIterator() = default;
   explicit StringMapConstIterator(StringMapEntryBase **Bucket,
                                   bool NoAdvance = false)
       : base(Bucket, NoAdvance) {}
 
-  value_type &operator*() const {
-    return *static_cast<value_type *>(*this->Ptr);
+  const StringMapEntry<ValueTy> &operator*() const {
+    return *static_cast<const StringMapEntry<ValueTy> *>(*this->Ptr);
   }
 };
 
@@ -509,15 +472,13 @@
       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
 
 public:
-  using value_type = StringMapEntry<ValueTy>;
-
   StringMapIterator() = default;
   explicit StringMapIterator(StringMapEntryBase **Bucket,
                              bool NoAdvance = false)
       : base(Bucket, NoAdvance) {}
 
-  value_type &operator*() const {
-    return *static_cast<value_type *>(*this->Ptr);
+  StringMapEntry<ValueTy> &operator*() const {
+    return *static_cast<StringMapEntry<ValueTy> *>(*this->Ptr);
   }
 
   operator StringMapConstIterator<ValueTy>() const {
@@ -539,13 +500,7 @@
   explicit StringMapKeyIterator(StringMapConstIterator<ValueTy> Iter)
       : base(std::move(Iter)) {}
 
-  std::string_view &operator*() {
-    Key = this->wrapped()->getKey();
-    return Key;
-  }
-
-private:
-  std::string_view Key;
+  std::string_view operator*() const { return this->wrapped()->getKey(); }
 };
 
 template <typename ValueTy>
@@ -635,4 +590,4 @@
 
 } // end namespace wpi
 
-#endif // LLVM_ADT_STRINGMAP_H
+#endif // WPIUTIL_WPI_STRINGMAP_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMapEntry.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMapEntry.h
new file mode 100644
index 0000000..2b33aa6
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/StringMapEntry.h
@@ -0,0 +1,153 @@
+//===- StringMapEntry.h - String Hash table map interface -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the StringMapEntry class - it is intended to be a low
+/// dependency implementation detail of StringMap that is more suitable for
+/// inclusion in public headers than StringMap.h itself is.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_STRINGMAPENTRY_H
+#define WPIUTIL_WPI_STRINGMAPENTRY_H
+
+#include "wpi/MemAlloc.h"
+
+#include <cassert>
+#include <cstring>
+#include <optional>
+#include <string_view>
+
+namespace wpi {
+
+/// StringMapEntryBase - Shared base class of StringMapEntry instances.
+class StringMapEntryBase {
+  size_t keyLength;
+
+public:
+  explicit StringMapEntryBase(size_t keyLength) : keyLength(keyLength) {}
+
+  size_t getKeyLength() const { return keyLength; }
+
+protected:
+  /// Helper to tail-allocate \p Key. It'd be nice to generalize this so it
+  /// could be reused elsewhere, maybe even taking an wpi::function_ref to
+  /// type-erase the allocator and put it in a source file.
+  template <typename AllocatorTy>
+  static void *allocateWithKey(size_t EntrySize, size_t EntryAlign,
+                               std::string_view Key, AllocatorTy &Allocator);
+};
+
+// Define out-of-line to dissuade inlining.
+template <typename AllocatorTy>
+void *StringMapEntryBase::allocateWithKey(size_t EntrySize, size_t EntryAlign,
+                                          std::string_view Key,
+                                          AllocatorTy &Allocator) {
+  size_t KeyLength = Key.size();
+
+  // Allocate a new item with space for the string at the end and a null
+  // terminator.
+  size_t AllocSize = EntrySize + KeyLength + 1;
+  void *Allocation = Allocator.Allocate(AllocSize, EntryAlign);
+  assert(Allocation && "Unhandled out-of-memory");
+
+  // Copy the string information.
+  char *Buffer = reinterpret_cast<char *>(Allocation) + EntrySize;
+  if (KeyLength > 0)
+    ::memcpy(Buffer, Key.data(), KeyLength);
+  Buffer[KeyLength] = 0; // Null terminate for convenience of clients.
+  return Allocation;
+}
+
+/// StringMapEntryStorage - Holds the value in a StringMapEntry.
+///
+/// Factored out into a separate base class to make it easier to specialize.
+/// This is primarily intended to support StringSet, which doesn't need a value
+/// stored at all.
+template <typename ValueTy>
+class StringMapEntryStorage : public StringMapEntryBase {
+public:
+  ValueTy second;
+
+  explicit StringMapEntryStorage(size_t keyLength)
+      : StringMapEntryBase(keyLength), second() {}
+  template <typename... InitTy>
+  StringMapEntryStorage(size_t keyLength, InitTy &&... initVals)
+      : StringMapEntryBase(keyLength),
+        second(std::forward<InitTy>(initVals)...) {}
+  StringMapEntryStorage(StringMapEntryStorage &e) = delete;
+
+  const ValueTy &getValue() const { return second; }
+  ValueTy &getValue() { return second; }
+
+  void setValue(const ValueTy &V) { second = V; }
+};
+
+template <> class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
+public:
+  explicit StringMapEntryStorage(size_t keyLength, std::nullopt_t = std::nullopt)
+      : StringMapEntryBase(keyLength) {}
+  StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
+
+  std::nullopt_t getValue() const { return std::nullopt; }
+};
+
+/// StringMapEntry - This is used to represent one value that is inserted into
+/// a StringMap.  It contains the Value itself and the key: the string length
+/// and data.
+template <typename ValueTy>
+class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
+public:
+  using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
+
+  std::string_view getKey() const {
+    return std::string_view(getKeyData(), this->getKeyLength());
+  }
+
+  /// getKeyData - Return the start of the string data that is the key for this
+  /// value.  The string data is always stored immediately after the
+  /// StringMapEntry object.
+  const char *getKeyData() const {
+    return reinterpret_cast<const char *>(this + 1);
+  }
+
+  std::string_view first() const {
+    return std::string_view(getKeyData(), this->getKeyLength());
+  }
+
+  /// Create a StringMapEntry for the specified key construct the value using
+  /// \p InitiVals.
+  template <typename AllocatorTy, typename... InitTy>
+  static StringMapEntry *Create(std::string_view key, AllocatorTy &allocator,
+                                InitTy &&... initVals) {
+    return new (StringMapEntryBase::allocateWithKey(
+        sizeof(StringMapEntry), alignof(StringMapEntry), key, allocator))
+        StringMapEntry(key.size(), std::forward<InitTy>(initVals)...);
+  }
+
+  /// GetStringMapEntryFromKeyData - Given key data that is known to be embedded
+  /// into a StringMapEntry, return the StringMapEntry itself.
+  static StringMapEntry &GetStringMapEntryFromKeyData(const char *keyData) {
+    char *ptr = const_cast<char *>(keyData) - sizeof(StringMapEntry<ValueTy>);
+    return *reinterpret_cast<StringMapEntry *>(ptr);
+  }
+
+  /// Destroy - Destroy this StringMapEntry, releasing memory back to the
+  /// specified allocator.
+  template <typename AllocatorTy> void Destroy(AllocatorTy &allocator) {
+    // Free memory referenced by the item.
+    size_t AllocSize = sizeof(StringMapEntry) + this->getKeyLength() + 1;
+    this->~StringMapEntry();
+    allocator.Deallocate(static_cast<void *>(this), AllocSize,
+                         alignof(StringMapEntry));
+  }
+};
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_STRINGMAPENTRY_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SwapByteOrder.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SwapByteOrder.h
new file mode 100644
index 0000000..ab2791a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/SwapByteOrder.h
@@ -0,0 +1,165 @@
+//===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares generic and optimized functions to swap the byte order of
+// an integral type.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_SWAPBYTEORDER_H
+#define WPIUTIL_WPI_SWAPBYTEORDER_H
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#if defined(_MSC_VER) && !defined(_DEBUG)
+#include <stdlib.h>
+#endif
+
+#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__) ||            \
+    defined(__Fuchsia__) || defined(__EMSCRIPTEN__)
+#include <endian.h>
+#elif defined(_AIX)
+#include <sys/machine.h>
+#elif defined(__sun)
+/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
+#include <sys/types.h>
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#if defined(_BIG_ENDIAN)
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif
+#elif defined(__MVS__)
+#define BIG_ENDIAN 4321
+#define LITTLE_ENDIAN 1234
+#define BYTE_ORDER BIG_ENDIAN
+#else
+#if !defined(BYTE_ORDER) && !defined(_WIN32)
+#include <machine/endian.h>
+#endif
+#endif
+
+namespace wpi {
+
+/// ByteSwap_16 - This function returns a byte-swapped representation of
+/// the 16-bit argument.
+inline uint16_t ByteSwap_16(uint16_t value) {
+#if defined(_MSC_VER) && !defined(_DEBUG)
+  // The DLL version of the runtime lacks these functions (bug!?), but in a
+  // release build they're replaced with BSWAP instructions anyway.
+  return _byteswap_ushort(value);
+#else
+  uint16_t Hi = value << 8;
+  uint16_t Lo = value >> 8;
+  return Hi | Lo;
+#endif
+}
+
+/// This function returns a byte-swapped representation of the 32-bit argument.
+inline uint32_t ByteSwap_32(uint32_t value) {
+#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
+  return __builtin_bswap32(value);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+  return _byteswap_ulong(value);
+#else
+  uint32_t Byte0 = value & 0x000000FF;
+  uint32_t Byte1 = value & 0x0000FF00;
+  uint32_t Byte2 = value & 0x00FF0000;
+  uint32_t Byte3 = value & 0xFF000000;
+  return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
+#endif
+}
+
+/// This function returns a byte-swapped representation of the 64-bit argument.
+inline uint64_t ByteSwap_64(uint64_t value) {
+#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
+  return __builtin_bswap64(value);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+  return _byteswap_uint64(value);
+#else
+  uint64_t Hi = ByteSwap_32(uint32_t(value));
+  uint32_t Lo = ByteSwap_32(uint32_t(value >> 32));
+  return (Hi << 32) | Lo;
+#endif
+}
+
+namespace sys {
+
+#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
+constexpr bool IsBigEndianHost = true;
+#else
+constexpr bool IsBigEndianHost = false;
+#endif
+
+static const bool IsLittleEndianHost = !IsBigEndianHost;
+
+inline unsigned char  getSwappedBytes(unsigned char C) { return C; }
+inline   signed char  getSwappedBytes(signed char C) { return C; }
+inline          char  getSwappedBytes(char C) { return C; }
+
+inline unsigned short getSwappedBytes(unsigned short C) { return ByteSwap_16(C); }
+inline   signed short getSwappedBytes(  signed short C) { return ByteSwap_16(C); }
+
+inline unsigned int   getSwappedBytes(unsigned int   C) { return ByteSwap_32(C); }
+inline   signed int   getSwappedBytes(  signed int   C) { return ByteSwap_32(C); }
+
+inline unsigned long getSwappedBytes(unsigned long C) {
+  // Handle LLP64 and LP64 platforms.
+  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
+                                     : ByteSwap_64((uint64_t)C);
+}
+inline signed long getSwappedBytes(signed long C) {
+  // Handle LLP64 and LP64 platforms.
+  return sizeof(long) == sizeof(int) ? ByteSwap_32((uint32_t)C)
+                                     : ByteSwap_64((uint64_t)C);
+}
+
+inline unsigned long long getSwappedBytes(unsigned long long C) {
+  return ByteSwap_64(C);
+}
+inline signed long long getSwappedBytes(signed long long C) {
+  return ByteSwap_64(C);
+}
+
+inline float getSwappedBytes(float C) {
+  union {
+    uint32_t i;
+    float f;
+  } in, out;
+  in.f = C;
+  out.i = ByteSwap_32(in.i);
+  return out.f;
+}
+
+inline double getSwappedBytes(double C) {
+  union {
+    uint64_t i;
+    double d;
+  } in, out;
+  in.d = C;
+  out.i = ByteSwap_64(in.i);
+  return out.d;
+}
+
+template <typename T>
+inline std::enable_if_t<std::is_enum<T>::value, T> getSwappedBytes(T C) {
+  return static_cast<T>(
+      getSwappedBytes(static_cast<std::underlying_type_t<T>>(C)));
+}
+
+template<typename T>
+inline void swapByteOrder(T &Value) {
+  Value = getSwappedBytes(Value);
+}
+
+} // end namespace sys
+} // end namespace wpi
+
+#endif
diff --git a/wpiutil/src/main/native/include/wpi/VersionTuple.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/VersionTuple.h
similarity index 82%
rename from wpiutil/src/main/native/include/wpi/VersionTuple.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/VersionTuple.h
index 59df41c..c08ff37 100644
--- a/wpiutil/src/main/native/include/wpi/VersionTuple.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/VersionTuple.h
@@ -1,9 +1,8 @@
 //===- VersionTuple.h - Version Number Handling -----------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
@@ -15,10 +14,14 @@
 #ifndef WPIUTIL_WPI_VERSIONTUPLE_H
 #define WPIUTIL_WPI_VERSIONTUPLE_H
 
+#include "wpi/DenseMapInfo.h"
+#include "wpi/Hashing.h"
 #include <optional>
 #include <string>
+#include <tuple>
 
 namespace wpi {
+class raw_ostream;
 
 /// Represents a version number in the form major[.minor[.subminor[.build]]].
 class VersionTuple {
@@ -85,6 +88,27 @@
     return Build;
   }
 
+  /// Return a version tuple that contains only the first 3 version components.
+  VersionTuple withoutBuild() const {
+    if (HasBuild)
+      return VersionTuple(Major, Minor, Subminor);
+    return *this;
+  }
+
+  /// Return a version tuple that contains only components that are non-zero.
+  VersionTuple normalize() const {
+    VersionTuple Result = *this;
+    if (Result.Build == 0) {
+      Result.HasBuild = false;
+      if (Result.Subminor == 0) {
+        Result.HasSubminor = false;
+        if (Result.Minor == 0)
+          Result.HasMinor = false;
+      }
+    }
+    return Result;
+  }
+
   /// Determine if two version numbers are equivalent. If not
   /// provided, minor and subminor version numbers are considered to be zero.
   friend bool operator==(const VersionTuple &X, const VersionTuple &Y) {
diff --git a/wpiutil/src/main/native/include/wpi/WindowsError.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/WindowsError.h
similarity index 62%
rename from wpiutil/src/main/native/include/wpi/WindowsError.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/WindowsError.h
index 565e2b7..54a5236 100644
--- a/wpiutil/src/main/native/include/wpi/WindowsError.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/WindowsError.h
@@ -1,9 +1,8 @@
 //===-- WindowsError.h - Support for mapping windows errors to posix-------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
diff --git a/wpiutil/src/main/native/include/wpi/function_ref.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/function_ref.h
similarity index 100%
rename from wpiutil/src/main/native/include/wpi/function_ref.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/function_ref.h
diff --git a/wpiutil/src/main/native/include/wpi/iterator.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator.h
similarity index 77%
rename from wpiutil/src/main/native/include/wpi/iterator.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator.h
index 70bbdab..f959fac 100644
--- a/wpiutil/src/main/native/include/wpi/iterator.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator.h
@@ -1,9 +1,8 @@
 //===- iterator.h - Utilities for using and defining iterators --*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -11,7 +10,6 @@
 #define WPIUTIL_WPI_ITERATOR_H
 
 #include "wpi/iterator_range.h"
-#include <algorithm>
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
@@ -37,6 +35,21 @@
 /// terms of addition of one. These aren't equivalent for all iterator
 /// categories, and respecting that adds a lot of complexity for little gain.
 ///
+/// Iterators are expected to have const rules analogous to pointers, with a
+/// single, const-qualified operator*() that returns ReferenceT. This matches
+/// the second and third pointers in the following example:
+/// \code
+///   int Value;
+///   { int *I = &Value; }             // ReferenceT 'int&'
+///   { int *const I = &Value; }       // ReferenceT 'int&'; const
+///   { const int *I = &Value; }       // ReferenceT 'const int&'
+///   { const int *const I = &Value; } // ReferenceT 'const int&'; const
+/// \endcode
+/// If an iterator facade returns a handle to its own state, then T (and
+/// PointerT and ReferenceT) should usually be const-qualified. Otherwise, if
+/// clients are expected to modify the handle itself, the field can be declared
+/// mutable or use const_cast.
+///
 /// Classes wishing to use `iterator_facade_base` should implement the following
 /// methods:
 ///
@@ -44,8 +57,7 @@
 ///   (All of the following methods)
 ///   - DerivedT &operator=(const DerivedT &R);
 ///   - bool operator==(const DerivedT &R) const;
-///   - const T &operator*() const;
-///   - T &operator*();
+///   - T &operator*() const;
 ///   - DerivedT &operator++();
 ///
 /// Bidirectional Iterators:
@@ -65,9 +77,14 @@
 template <typename DerivedT, typename IteratorCategoryT, typename T,
           typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
           typename ReferenceT = T &>
-class iterator_facade_base
-    : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,
-                           ReferenceT> {
+class iterator_facade_base {
+public:
+  using iterator_category = IteratorCategoryT;
+  using value_type = T;
+  using difference_type = DifferenceTypeT;
+  using pointer = PointerT;
+  using reference = ReferenceT;
+
 protected:
   enum {
     IsRandomAccess = std::is_base_of<std::random_access_iterator_tag,
@@ -92,6 +109,22 @@
     operator ReferenceT() const { return *I; }
   };
 
+  /// A proxy object for computing a pointer via indirecting a copy of a
+  /// reference. This is used in APIs which need to produce a pointer but for
+  /// which the reference might be a temporary. The proxy preserves the
+  /// reference internally and exposes the pointer via a arrow operator.
+  class PointerProxy {
+    friend iterator_facade_base;
+
+    ReferenceT R;
+
+    template <typename RefT>
+    PointerProxy(RefT &&R) : R(std::forward<RefT>(R)) {}
+
+  public:
+    PointerT operator->() const { return &R; }
+  };
+
 public:
   DerivedT operator+(DifferenceTypeT n) const {
     static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
@@ -143,43 +176,39 @@
     return tmp;
   }
 
+#ifndef __cpp_impl_three_way_comparison
   bool operator!=(const DerivedT &RHS) const {
-    return !static_cast<const DerivedT *>(this)->operator==(RHS);
+    return !(static_cast<const DerivedT &>(*this) == RHS);
   }
+#endif
 
   bool operator>(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS) &&
-           !static_cast<const DerivedT *>(this)->operator==(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS) &&
+           !(static_cast<const DerivedT &>(*this) == RHS);
   }
   bool operator<=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator>(RHS);
+    return !(static_cast<const DerivedT &>(*this) > RHS);
   }
   bool operator>=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS);
   }
 
-  PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
-  PointerT operator->() const {
-    return &static_cast<const DerivedT *>(this)->operator*();
-  }
-  ReferenceProxy operator[](DifferenceTypeT n) {
-    static_assert(IsRandomAccess,
-                  "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<DerivedT *>(this)->operator+(n));
+  PointerProxy operator->() const {
+    return static_cast<const DerivedT *>(this)->operator*();
   }
   ReferenceProxy operator[](DifferenceTypeT n) const {
     static_assert(IsRandomAccess,
                   "Subscripting is only defined for random access iterators.");
-    return ReferenceProxy(static_cast<const DerivedT *>(this)->operator+(n));
+    return static_cast<const DerivedT *>(this)->operator+(n);
   }
 };
 
@@ -195,14 +224,14 @@
     typename T = typename std::iterator_traits<WrappedIteratorT>::value_type,
     typename DifferenceTypeT =
         typename std::iterator_traits<WrappedIteratorT>::difference_type,
-    typename PointerT = typename std::conditional<
+    typename PointerT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::pointer, T *>::type,
-    typename ReferenceT = typename std::conditional<
+        typename std::iterator_traits<WrappedIteratorT>::pointer, T *>,
+    typename ReferenceT = std::conditional_t<
         std::is_same<T, typename std::iterator_traits<
                             WrappedIteratorT>::value_type>::value,
-        typename std::iterator_traits<WrappedIteratorT>::reference, T &>::type>
+        typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
 class iterator_adaptor_base
     : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
                                   DifferenceTypeT, PointerT, ReferenceT> {
@@ -261,12 +290,16 @@
     return *static_cast<DerivedT *>(this);
   }
 
-  bool operator==(const DerivedT &RHS) const { return I == RHS.I; }
-  bool operator<(const DerivedT &RHS) const {
+  friend bool operator==(const iterator_adaptor_base &LHS,
+                         const iterator_adaptor_base &RHS) {
+    return LHS.I == RHS.I;
+  }
+  friend bool operator<(const iterator_adaptor_base &LHS,
+                        const iterator_adaptor_base &RHS) {
     static_assert(
         BaseT::IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return I < RHS.I;
+    return LHS.I < RHS.I;
   }
 
   ReferenceT operator*() const { return *I; }
@@ -282,8 +315,8 @@
 ///   using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
 /// \endcode
 template <typename WrappedIteratorT,
-          typename T = typename std::remove_reference<
-              decltype(**std::declval<WrappedIteratorT>())>::type>
+          typename T = std::remove_reference_t<decltype(
+              **std::declval<WrappedIteratorT>())>>
 struct pointee_iterator
     : iterator_adaptor_base<
           pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
@@ -321,8 +354,7 @@
   explicit pointer_iterator(WrappedIteratorT u)
       : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
 
-  T &operator*() { return Ptr = &*this->I; }
-  const T &operator*() const { return Ptr = &*this->I; }
+  T &operator*() const { return Ptr = &*this->I; }
 };
 
 template <typename RangeT, typename WrappedIteratorT =
@@ -334,6 +366,13 @@
                     PointerIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
+template <typename WrappedIteratorT,
+          typename T1 = std::remove_reference_t<decltype(
+              **std::declval<WrappedIteratorT>())>,
+          typename T2 = std::add_pointer_t<T1>>
+using raw_pointer_iterator =
+    pointer_iterator<pointee_iterator<WrappedIteratorT, T1>, T2>;
+
 } // end namespace wpi
 
-#endif // LLVM_ADT_ITERATOR_H
+#endif // WPIUTIL_WPI_ITERATOR_H
diff --git a/wpiutil/src/main/native/include/wpi/iterator_range.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator_range.h
similarity index 82%
rename from wpiutil/src/main/native/include/wpi/iterator_range.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator_range.h
index 78a60c2..ce0e4ee 100644
--- a/wpiutil/src/main/native/include/wpi/iterator_range.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/iterator_range.h
@@ -1,9 +1,8 @@
 //===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
@@ -19,7 +18,6 @@
 #ifndef WPIUTIL_WPI_ITERATOR_RANGE_H
 #define WPIUTIL_WPI_ITERATOR_RANGE_H
 
-#include <iterator>
 #include <utility>
 
 namespace wpi {
@@ -45,6 +43,7 @@
 
   IteratorT begin() const { return begin_iterator; }
   IteratorT end() const { return end_iterator; }
+  bool empty() const { return begin_iterator == end_iterator; }
 };
 
 /// Convenience function for iterating over sub-ranges.
@@ -59,11 +58,6 @@
   return iterator_range<T>(std::move(p.first), std::move(p.second));
 }
 
-template <typename T>
-iterator_range<decltype(adl_begin(std::declval<T>()))> drop_begin(T &&t,
-                                                                  int n) {
-  return make_range(std::next(adl_begin(t), n), adl_end(t));
-}
 }
 
 #endif
diff --git a/wpiutil/src/main/native/include/wpi/raw_os_ostream.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_os_ostream.h
similarity index 84%
rename from wpiutil/src/main/native/include/wpi/raw_os_ostream.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_os_ostream.h
index 4335e02..87cd596 100644
--- a/wpiutil/src/main/native/include/wpi/raw_os_ostream.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_os_ostream.h
@@ -1,9 +1,8 @@
 //===- raw_os_ostream.h - std::ostream adaptor for raw_ostream --*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
diff --git a/wpiutil/src/main/native/include/wpi/raw_ostream.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_ostream.h
similarity index 74%
rename from wpiutil/src/main/native/include/wpi/raw_ostream.h
rename to wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_ostream.h
index 84ec925..350262b 100644
--- a/wpiutil/src/main/native/include/wpi/raw_ostream.h
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/raw_ostream.h
@@ -1,9 +1,8 @@
 //===--- raw_ostream.h - Raw output stream ----------------------*- C++ -*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
@@ -15,20 +14,25 @@
 #define WPIUTIL_WPI_RAW_OSTREAM_H
 
 #include "wpi/SmallVector.h"
-#include "wpi/span.h"
+#include <span>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <string>
+#if __cplusplus > 201402L
 #include <string_view>
-#include <vector>
+#endif
 #include <system_error>
+#include <type_traits>
+#include <vector>
+
 
 namespace fs {
 enum FileAccess : unsigned;
 enum OpenFlags : unsigned;
 enum CreationDisposition : unsigned;
+class FileLocker;
 } // end namespace fs
 
 namespace wpi {
@@ -38,7 +42,16 @@
 /// buffered disciplines etc. It is a simple buffer that outputs
 /// a chunk at a time.
 class raw_ostream {
+public:
+  // Class kinds to support LLVM-style RTTI.
+  enum class OStreamKind {
+    OK_OStream,
+    OK_FDStream,
+  };
+
 private:
+  OStreamKind Kind;
+
   /// The buffer is handled in such a way that the buffer is
   /// uninitialized, unbuffered, or out of space when OutBufCur >=
   /// OutBufEnd. Thus a single comparison suffices to determine if we
@@ -59,7 +72,11 @@
   /// this buffer.
   char *OutBufStart, *OutBufEnd, *OutBufCur;
 
-  enum BufferKind {
+  /// Optional stream this stream is tied to. If this stream is written to, the
+  /// tied-to stream will be flushed first.
+  raw_ostream *TiedStream = nullptr;
+
+  enum class BufferKind {
     Unbuffered = 0,
     InternalBuffer,
     ExternalBuffer
@@ -67,7 +84,7 @@
 
 public:
   // color order matches ANSI escape sequence, don't change
-  enum Colors {
+  enum class Colors {
     BLACK = 0,
     RED,
     GREEN,
@@ -76,11 +93,25 @@
     MAGENTA,
     CYAN,
     WHITE,
-    SAVEDCOLOR
+    SAVEDCOLOR,
+    RESET,
   };
 
-  explicit raw_ostream(bool unbuffered = false)
-      : BufferMode(unbuffered ? Unbuffered : InternalBuffer) {
+  static constexpr Colors BLACK = Colors::BLACK;
+  static constexpr Colors RED = Colors::RED;
+  static constexpr Colors GREEN = Colors::GREEN;
+  static constexpr Colors YELLOW = Colors::YELLOW;
+  static constexpr Colors BLUE = Colors::BLUE;
+  static constexpr Colors MAGENTA = Colors::MAGENTA;
+  static constexpr Colors CYAN = Colors::CYAN;
+  static constexpr Colors WHITE = Colors::WHITE;
+  static constexpr Colors SAVEDCOLOR = Colors::SAVEDCOLOR;
+  static constexpr Colors RESET = Colors::RESET;
+
+  explicit raw_ostream(bool unbuffered = false,
+                       OStreamKind K = OStreamKind::OK_OStream)
+      : Kind(K), BufferMode(unbuffered ? BufferKind::Unbuffered
+                                       : BufferKind::InternalBuffer) {
     // Start out ready to flush.
     OutBufStart = OutBufEnd = OutBufCur = nullptr;
   }
@@ -93,10 +124,19 @@
   /// tell - Return the current offset with the file.
   uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
 
+  OStreamKind get_kind() const { return Kind; }
+
   //===--------------------------------------------------------------------===//
   // Configuration Interface
   //===--------------------------------------------------------------------===//
 
+  /// If possible, pre-allocate \p ExtraSize bytes for stream data.
+  /// i.e. it extends internal buffers to keep additional ExtraSize bytes.
+  /// So that the stream could keep at least tell() + ExtraSize bytes
+  /// without re-allocations. reserveExtraSpace() does not change
+  /// the size/data of the stream.
+  virtual void reserveExtraSpace(uint64_t ExtraSize) {}
+
   /// Set the stream to be buffered, with an automatically determined buffer
   /// size.
   void SetBuffered();
@@ -104,13 +144,13 @@
   /// Set the stream to be buffered, using the specified buffer size.
   void SetBufferSize(size_t Size) {
     flush();
-    SetBufferAndMode(new char[Size], Size, InternalBuffer);
+    SetBufferAndMode(new char[Size], Size, BufferKind::InternalBuffer);
   }
 
   size_t GetBufferSize() const {
     // If we're supposed to be buffered but haven't actually gotten around
     // to allocating the buffer yet, return the value that would be used.
-    if (BufferMode != Unbuffered && OutBufStart == nullptr)
+    if (BufferMode != BufferKind::Unbuffered && OutBufStart == nullptr)
       return preferred_buffer_size();
 
     // Otherwise just return the size of the allocated buffer.
@@ -122,7 +162,7 @@
   /// when the stream is being set to unbuffered.
   void SetUnbuffered() {
     flush();
-    SetBufferAndMode(nullptr, 0, Unbuffered);
+    SetBufferAndMode(nullptr, 0, BufferKind::Unbuffered);
   }
 
   size_t GetNumBytesInBuffer() const {
@@ -159,7 +199,7 @@
     return *this;
   }
 
-  raw_ostream &operator<<(span<const uint8_t> Arr) {
+  raw_ostream &operator<<(std::span<const uint8_t> Arr) {
     // Inline fast path, particularly for arrays with a known length.
     size_t Size = Arr.size();
 
@@ -237,9 +277,8 @@
   /// @param Bold bold/brighter text, default false
   /// @param BG if true change the background, default: change foreground
   /// @returns itself so it can be used within << invocations
-  virtual raw_ostream &changeColor(enum Colors Color,
-                                   bool Bold = false,
-                                   bool BG = false) {
+  virtual raw_ostream &changeColor(enum Colors Color, bool Bold = false,
+                                   bool BG = false)  {
     (void)Color;
     (void)Bold;
     (void)BG;
@@ -259,8 +298,19 @@
   virtual bool is_displayed() const { return false; }
 
   /// This function determines if this stream is displayed and supports colors.
+  /// The result is unaffected by calls to enable_color().
   virtual bool has_colors() const { return is_displayed(); }
 
+  // Enable or disable colors. Once enable_colors(false) is called,
+  // changeColor() has no effect until enable_colors(true) is called.
+  virtual void enable_colors(bool /*enable*/) {}
+
+  bool colors_enabled() const { return false; }
+
+  /// Tie this stream to the specified stream. Replaces any existing tied-to
+  /// stream. Specifying a nullptr unties the stream.
+  void tie(raw_ostream *TieTo) { TiedStream = TieTo; }
+
   //===--------------------------------------------------------------------===//
   // Subclass Interface
   //===--------------------------------------------------------------------===//
@@ -281,9 +331,6 @@
   /// \invariant { Size > 0 }
   virtual void write_impl(const char *Ptr, size_t Size) = 0;
 
-  // An out of line virtual method to provide a home for the class vtable.
-  virtual void handle();
-
   /// Return the current position within the stream, not counting the bytes
   /// currently in the buffer.
   virtual uint64_t current_pos() const = 0;
@@ -293,7 +340,7 @@
   /// use only by subclasses which can arrange for the output to go directly
   /// into the desired output buffer, instead of being copied on each flush.
   void SetBuffer(char *BufferStart, size_t Size) {
-    SetBufferAndMode(BufferStart, Size, ExternalBuffer);
+    SetBufferAndMode(BufferStart, Size, BufferKind::ExternalBuffer);
   }
 
   /// Return an efficient buffer size for the underlying output mechanism.
@@ -318,9 +365,23 @@
   /// unused bytes in the buffer.
   void copy_to_buffer(const char *Ptr, size_t Size);
 
+  /// Flush the tied-to stream (if present) and then write the required data.
+  void flush_tied_then_write(const char *Ptr, size_t Size);
+
   virtual void anchor();
 };
 
+/// Call the appropriate insertion operator, given an rvalue reference to a
+/// raw_ostream object and return a stream of the same type as the argument.
+template <typename OStream, typename T>
+std::enable_if_t<!std::is_reference<OStream>::value &&
+                     std::is_base_of<raw_ostream, OStream>::value,
+                 OStream &&>
+operator<<(OStream &&OS, const T &Value) {
+  OS << Value;
+  return std::move(OS);
+}
+
 /// An abstract base class for streams implementations that also support a
 /// pwrite operation. This is useful for code that can mostly stream out data,
 /// but needs to patch in a header that needs to know the output size.
@@ -329,10 +390,11 @@
   void anchor() override;
 
 public:
-  explicit raw_pwrite_stream(bool Unbuffered = false)
-      : raw_ostream(Unbuffered) {}
+  explicit raw_pwrite_stream(bool Unbuffered = false,
+                             OStreamKind K = OStreamKind::OK_OStream)
+      : raw_ostream(Unbuffered, K) {}
   void pwrite(const char *Ptr, size_t Size, uint64_t Offset) {
-#ifndef NDBEBUG
+#ifndef NDEBUG
     uint64_t Pos = tell();
     // /dev/null always reports a pos of 0, so we cannot perform this check
     // in that case.
@@ -352,8 +414,8 @@
 class raw_fd_ostream : public raw_pwrite_stream {
   int FD;
   bool ShouldClose;
-
-  bool SupportsSeeking;
+  bool SupportsSeeking = false;
+  bool IsRegularFile = false;
 
 #ifdef _WIN32
   /// True if this fd refers to a Windows console device. Mintty and other
@@ -363,7 +425,7 @@
 
   std::error_code EC;
 
-  uint64_t pos;
+  uint64_t pos = 0;
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
@@ -377,10 +439,17 @@
   /// Determine an efficient buffer size.
   size_t preferred_buffer_size() const override;
 
+  void anchor() override;
+
+protected:
   /// Set the flag indicating that an output error has been encountered.
   void error_detected(std::error_code EC) { this->EC = EC; }
 
-  void anchor() override;
+  /// Return the file descriptor.
+  int get_fd() const { return FD; }
+
+  // Update the file position by increasing \p Delta.
+  void inc_pos(uint64_t Delta) { pos += Delta; }
 
 public:
   /// Open the specified file for writing. If an error occurs, information
@@ -405,7 +474,8 @@
   /// FD is the file descriptor that this writes to.  If ShouldClose is true,
   /// this closes the file when the stream is destroyed. If FD is for stdout or
   /// stderr, it will not be closed.
-  raw_fd_ostream(int fd, bool shouldClose, bool unbuffered=false);
+  raw_fd_ostream(int fd, bool shouldClose, bool unbuffered = false,
+                 OStreamKind K = OStreamKind::OK_OStream);
 
   ~raw_fd_ostream() override;
 
@@ -413,7 +483,9 @@
   /// fsync.
   void close();
 
-  bool supportsSeeking() { return SupportsSeeking; }
+  bool supportsSeeking() const { return SupportsSeeking; }
+
+  bool isRegularFile() const { return IsRegularFile; }
 
   /// Flushes the stream and repositions the underlying file descriptor position
   /// to the offset specified from the beginning of the file.
@@ -439,23 +511,46 @@
   void clear_error() { EC = std::error_code(); }
 };
 
-/// This returns a reference to a raw_ostream for standard output. Use it like:
-/// outs() << "foo" << "bar";
-raw_ostream &outs();
+/// This returns a reference to a raw_fd_ostream for standard output. Use it
+/// like: outs() << "foo" << "bar";
+raw_fd_ostream &outs();
 
-/// This returns a reference to a raw_ostream for standard error. Use it like:
-/// errs() << "foo" << "bar";
-raw_ostream &errs();
+/// This returns a reference to a raw_ostream for standard error.
+/// Use it like: errs() << "foo" << "bar";
+/// By default, the stream is tied to stdout to ensure stdout is flushed before
+/// stderr is written, to ensure the error messages are written in their
+/// expected place.
+raw_fd_ostream &errs();
 
 /// This returns a reference to a raw_ostream which simply discards output.
 raw_ostream &nulls();
 
 //===----------------------------------------------------------------------===//
+// File Streams
+//===----------------------------------------------------------------------===//
+
+/// A raw_ostream of a file for reading/writing/seeking.
+///
+class raw_fd_stream : public raw_fd_ostream {
+public:
+  /// Open the specified file for reading/writing/seeking. If an error occurs,
+  /// information about the error is put into EC, and the stream should be
+  /// immediately destroyed.
+  raw_fd_stream(std::string_view Filename, std::error_code &EC);
+
+  /// Check if \p OS is a pointer of type raw_fd_stream*.
+  static bool classof(const raw_ostream *OS);
+};
+
+//===----------------------------------------------------------------------===//
 // Output Stream Adaptors
 //===----------------------------------------------------------------------===//
 
 /// A raw_ostream that writes to an std::string.  This is a simple adaptor
 /// class. This class does not encounter output errors.
+/// raw_string_ostream operates without a buffer, delegating all memory
+/// management to the std::string. Thus the std::string is always up-to-date,
+/// may be used directly and there is no need to call flush().
 class raw_string_ostream : public raw_ostream {
   std::string &OS;
 
@@ -467,14 +562,17 @@
   uint64_t current_pos() const override { return OS.size(); }
 
 public:
-  explicit raw_string_ostream(std::string &O) : OS(O) {}
-  ~raw_string_ostream() override;
+  explicit raw_string_ostream(std::string &O) : OS(O) {
+    SetUnbuffered();
+  }
 
-  /// Flushes the stream contents to the target string and returns  the string's
-  /// reference.
-  std::string& str() {
-    flush();
-    return OS;
+  /// Returns the string's reference. In most cases it is better to simply use
+  /// the underlying std::string directly.
+  /// TODO: Consider removing this API.
+  std::string &str() { return OS; }
+
+  void reserveExtraSpace(uint64_t ExtraSize) override {
+    OS.reserve(tell() + ExtraSize);
   }
 };
 
@@ -508,7 +606,11 @@
   void flush() = delete;
 
   /// Return a std::string_view for the vector contents.
-  std::string_view str() { return std::string_view(OS.data(), OS.size()); }
+  std::string_view str() const { return std::string_view(OS.data(), OS.size()); }
+
+  void reserveExtraSpace(uint64_t ExtraSize) override {
+    OS.reserve(tell() + ExtraSize);
+  }
 };
 
 /// A raw_ostream that writes to a vector.  This is a
@@ -573,9 +675,9 @@
 
   void flush() = delete;
 
-  /// Return an span for the vector contents.
-  span<uint8_t> array() { return {OS.data(), OS.size()}; }
-  span<const uint8_t> array() const { return {OS.data(), OS.size()}; }
+  /// Return an std::span for the vector contents.
+  std::span<uint8_t> array() { return {OS.data(), OS.size()}; }
+  std::span<const uint8_t> array() const { return {OS.data(), OS.size()}; }
 };
 
 /// A raw_ostream that writes to a vector.  This is a
@@ -607,9 +709,9 @@
 
   void flush() = delete;
 
-  /// Return a span for the vector contents.
-  span<uint8_t> array() { return {OS.data(), OS.size()}; }
-  span<const uint8_t> array() const { return {OS.data(), OS.size()}; }
+  /// Return a std::span for the vector contents.
+  std::span<uint8_t> array() { return {OS.data(), OS.size()}; }
+  std::span<const uint8_t> array() const { return {OS.data(), OS.size()}; }
 };
 
 
@@ -639,6 +741,22 @@
   ~buffer_ostream() override { OS << str(); }
 };
 
+class buffer_unique_ostream : public raw_svector_ostream {
+  std::unique_ptr<raw_ostream> OS;
+  SmallVector<char, 0> Buffer;
+
+  virtual void anchor() override;
+
+public:
+  buffer_unique_ostream(std::unique_ptr<raw_ostream> OS)
+      : raw_svector_ostream(Buffer), OS(std::move(OS)) {
+    // Turn off buffering on OS, which we now own, to avoid allocating a buffer
+    // when the destructor writes only to be immediately flushed again.
+    this->OS->SetUnbuffered();
+  }
+  ~buffer_unique_ostream() override { *OS << str(); }
+};
+
 } // end namespace wpi
 
-#endif // LLVM_SUPPORT_RAW_OSTREAM_H
+#endif // WPIUTIL_WPI_RAW_OSTREAM_H
diff --git a/wpiutil/src/main/native/thirdparty/llvm/include/wpi/type_traits.h b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/type_traits.h
new file mode 100644
index 0000000..53e18d3
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/llvm/include/wpi/type_traits.h
@@ -0,0 +1,104 @@
+//===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides useful additions to the standard type_traits library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef WPIUTIL_WPI_TYPE_TRAITS_H
+#define WPIUTIL_WPI_TYPE_TRAITS_H
+
+#include "wpi/Compiler.h"
+#include <type_traits>
+#include <utility>
+
+namespace wpi {
+
+
+/// Metafunction that determines whether the given type is either an
+/// integral type or an enumeration type, including enum classes.
+///
+/// Note that this accepts potentially more integral types than is_integral
+/// because it is based on being implicitly convertible to an integral type.
+/// Also note that enum classes aren't implicitly convertible to integral types,
+/// the value may therefore need to be explicitly converted before being used.
+template <typename T> class is_integral_or_enum {
+  using UnderlyingT = std::remove_reference_t<T>;
+
+public:
+  static const bool value =
+      !std::is_class<UnderlyingT>::value && // Filter conversion operators.
+      !std::is_pointer<UnderlyingT>::value &&
+      !std::is_floating_point<UnderlyingT>::value &&
+      (std::is_enum<UnderlyingT>::value ||
+       std::is_convertible<UnderlyingT, unsigned long long>::value);
+};
+
+/// If T is a pointer, just return it. If it is not, return T&.
+template<typename T, typename Enable = void>
+struct add_lvalue_reference_if_not_pointer { using type = T &; };
+
+template <typename T>
+struct add_lvalue_reference_if_not_pointer<
+    T, std::enable_if_t<std::is_pointer<T>::value>> {
+  using type = T;
+};
+
+/// If T is a pointer to X, return a pointer to const X. If it is not,
+/// return const T.
+template<typename T, typename Enable = void>
+struct add_const_past_pointer { using type = const T; };
+
+template <typename T>
+struct add_const_past_pointer<T, std::enable_if_t<std::is_pointer<T>::value>> {
+  using type = const std::remove_pointer_t<T> *;
+};
+
+template <typename T, typename Enable = void>
+struct const_pointer_or_const_ref {
+  using type = const T &;
+};
+template <typename T>
+struct const_pointer_or_const_ref<T,
+                                  std::enable_if_t<std::is_pointer<T>::value>> {
+  using type = typename add_const_past_pointer<T>::type;
+};
+
+namespace detail {
+/// Internal utility to detect trivial copy construction.
+template<typename T> union copy_construction_triviality_helper {
+    T t;
+    copy_construction_triviality_helper() = default;
+    copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default;
+    ~copy_construction_triviality_helper() = default;
+};
+/// Internal utility to detect trivial move construction.
+template<typename T> union move_construction_triviality_helper {
+    T t;
+    move_construction_triviality_helper() = default;
+    move_construction_triviality_helper(move_construction_triviality_helper&&) = default;
+    ~move_construction_triviality_helper() = default;
+};
+
+template<class T>
+union trivial_helper {
+    T t;
+};
+
+} // end namespace detail
+
+template <typename T>
+using is_trivially_move_constructible = std::is_trivially_move_constructible<T>;
+
+template <typename T>
+using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
+
+
+} // end namespace wpi
+
+#endif // WPIUTIL_WPI_TYPE_TRAITS_H
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/aligned_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/aligned_allocator.hpp
new file mode 100644
index 0000000..8118ec4
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/aligned_allocator.hpp
@@ -0,0 +1,197 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_ALIGNED_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_ALIGNED_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::aligned_allocator and related functions.
+
+#include <type_traits>
+
+#include "detail/assert.hpp"
+#include "detail/utility.hpp"
+#include "allocator_traits.hpp"
+#include "config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A \concept{concept_rawallocator,RawAllocator} adapter that ensures a minimum alignment.
+        /// It adjusts the alignment value so that it is always larger than the minimum and forwards to the specified allocator.
+        /// \ingroup adapter
+        template <class RawAllocator>
+        class aligned_allocator : WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+            using traits            = allocator_traits<RawAllocator>;
+            using composable_traits = composable_allocator_traits<RawAllocator>;
+            using composable        = is_composable_allocator<typename traits::allocator_type>;
+
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+            using is_stateful    = std::true_type;
+
+            /// \effects Creates it passing it the minimum alignment value and the allocator object.
+            /// \requires \c min_alignment must be less than \c this->max_alignment().
+            explicit aligned_allocator(std::size_t min_alignment, allocator_type&& alloc = {})
+            : allocator_type(detail::move(alloc)), min_alignment_(min_alignment)
+            {
+                WPI_MEMORY_ASSERT(min_alignment_ <= max_alignment());
+            }
+
+            /// @{
+            /// \effects Moves the \c aligned_allocator object.
+            /// It simply moves the underlying allocator.
+            aligned_allocator(aligned_allocator&& other) noexcept
+            : allocator_type(detail::move(other)), min_alignment_(other.min_alignment_)
+            {
+            }
+
+            aligned_allocator& operator=(aligned_allocator&& other) noexcept
+            {
+                allocator_type::operator=(detail::move(other));
+                min_alignment_          = other.min_alignment_;
+                return *this;
+            }
+            /// @}
+
+            /// @{
+            /// \effects Forwards to the underlying allocator through the \ref allocator_traits.
+            /// If the \c alignment is less than the \c min_alignment(), it is set to the minimum alignment.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return traits::allocate_node(get_allocator(), size, alignment);
+            }
+
+            void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return traits::allocate_array(get_allocator(), count, size, alignment);
+            }
+
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                traits::deallocate_node(get_allocator(), ptr, size, alignment);
+            }
+
+            void deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                  std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                traits::deallocate_array(get_allocator(), ptr, count, size, alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \effects Forwards to the underlying allocator through the \ref composable_allocator_traits.
+            /// If the \c alignment is less than the \c min_alignment(), it is set to the minimum alignment.
+            /// \requires The underyling allocator must be composable.
+            WPI_ENABLE_IF(composable::value)
+            void* try_allocate_node(std::size_t size, std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return composable_traits::try_allocate_node(get_allocator(), size, alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            void* try_allocate_array(std::size_t count, std::size_t size,
+                                     std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return composable_traits::try_allocate_array(get_allocator(), count, size,
+                                                             alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            bool try_deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return composable_traits::try_deallocate_node(get_allocator(), ptr, size,
+                                                              alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            bool try_deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                      std::size_t alignment) noexcept
+            {
+                if (min_alignment_ > alignment)
+                    alignment = min_alignment_;
+                return composable_traits::try_deallocate_array(get_allocator(), ptr, count, size,
+                                                               alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \returns The value returned by the \ref allocator_traits for the underlying allocator.
+            std::size_t max_node_size() const
+            {
+                return traits::max_node_size(get_allocator());
+            }
+
+            std::size_t max_array_size() const
+            {
+                return traits::max_array_size(get_allocator());
+            }
+
+            std::size_t max_alignment() const
+            {
+                return traits::max_alignment(get_allocator());
+            }
+            /// @}
+
+            /// @{
+            /// \returns A reference to the underlying allocator.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+            /// \returns The minimum alignment.
+            std::size_t min_alignment() const noexcept
+            {
+                return min_alignment_;
+            }
+
+            /// \effects Sets the minimum alignment to a new value.
+            /// \requires \c min_alignment must be less than \c this->max_alignment().
+            void set_min_alignment(std::size_t min_alignment)
+            {
+                WPI_MEMORY_ASSERT(min_alignment <= max_alignment());
+                min_alignment_ = min_alignment;
+            }
+
+        private:
+            std::size_t min_alignment_;
+        };
+
+        /// \returns A new \ref aligned_allocator created by forwarding the parameters to the constructor.
+        /// \relates aligned_allocator
+        template <class RawAllocator>
+        auto make_aligned_allocator(std::size_t min_alignment, RawAllocator&& allocator) noexcept
+            -> aligned_allocator<typename std::decay<RawAllocator>::type>
+        {
+            return aligned_allocator<
+                typename std::decay<RawAllocator>::type>{min_alignment,
+                                                         detail::forward<RawAllocator>(allocator)};
+        }
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_ALIGNED_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_storage.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_storage.hpp
new file mode 100644
index 0000000..8dab2e0
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_storage.hpp
@@ -0,0 +1,932 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_ALLOCATOR_STORAGE_HPP_INCLUDED
+#define WPI_MEMORY_ALLOCATOR_STORAGE_HPP_INCLUDED
+
+/// \file
+/// Class template \ref wpi::memory::allocator_storage, some policies and resulting typedefs.
+
+#include <new>
+#include <type_traits>
+
+#include "detail/utility.hpp"
+#include "config.hpp"
+#include "allocator_traits.hpp"
+#include "threading.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <class Alloc>
+            void* try_allocate_node(std::true_type, Alloc& alloc, std::size_t size,
+                                    std::size_t alignment) noexcept
+            {
+                return composable_allocator_traits<Alloc>::try_allocate_node(alloc, size,
+                                                                             alignment);
+            }
+
+            template <class Alloc>
+            void* try_allocate_array(std::true_type, Alloc& alloc, std::size_t count,
+                                     std::size_t size, std::size_t alignment) noexcept
+            {
+                return composable_allocator_traits<Alloc>::try_allocate_array(alloc, count, size,
+                                                                              alignment);
+            }
+
+            template <class Alloc>
+            bool try_deallocate_node(std::true_type, Alloc& alloc, void* ptr, std::size_t size,
+                                     std::size_t alignment) noexcept
+            {
+                return composable_allocator_traits<Alloc>::try_deallocate_node(alloc, ptr, size,
+                                                                               alignment);
+            }
+
+            template <class Alloc>
+            bool try_deallocate_array(std::true_type, Alloc& alloc, void* ptr, std::size_t count,
+                                      std::size_t size, std::size_t alignment) noexcept
+            {
+                return composable_allocator_traits<Alloc>::try_deallocate_array(alloc, ptr, count,
+                                                                                size, alignment);
+            }
+
+            template <class Alloc>
+            void* try_allocate_node(std::false_type, Alloc&, std::size_t, std::size_t) noexcept
+            {
+                WPI_MEMORY_UNREACHABLE("Allocator is not compositioning");
+                return nullptr;
+            }
+
+            template <class Alloc>
+            void* try_allocate_array(std::false_type, Alloc&, std::size_t, std::size_t,
+                                     std::size_t) noexcept
+            {
+                WPI_MEMORY_UNREACHABLE("Allocator is not compositioning");
+                return nullptr;
+            }
+
+            template <class Alloc>
+            bool try_deallocate_node(std::false_type, Alloc&, void*, std::size_t,
+                                     std::size_t) noexcept
+            {
+                WPI_MEMORY_UNREACHABLE("Allocator is not compositioning");
+                return false;
+            }
+
+            template <class Alloc>
+            bool try_deallocate_array(std::false_type, Alloc&, void*, std::size_t, std::size_t,
+                                      std::size_t) noexcept
+            {
+                WPI_MEMORY_UNREACHABLE("Allocator is not compositioning");
+                return false;
+            }
+        } // namespace detail
+
+        /// A \concept{concept_rawallocator,RawAllocator} that stores another allocator.
+        /// The \concept{concept_storagepolicy,StoragePolicy} defines the allocator type being stored and how it is stored.
+        /// The \c Mutex controls synchronization of the access.
+        /// \ingroup storage
+        template <class StoragePolicy, class Mutex>
+        class allocator_storage
+        : WPI_EBO(StoragePolicy,
+                        detail::mutex_storage<
+                            detail::mutex_for<typename StoragePolicy::allocator_type, Mutex>>)
+        {
+            using traits = allocator_traits<typename StoragePolicy::allocator_type>;
+            using composable_traits =
+                composable_allocator_traits<typename StoragePolicy::allocator_type>;
+            using composable   = is_composable_allocator<typename StoragePolicy::allocator_type>;
+            using actual_mutex = const detail::mutex_storage<
+                detail::mutex_for<typename StoragePolicy::allocator_type, Mutex>>;
+
+        public:
+            using allocator_type = typename StoragePolicy::allocator_type;
+            using storage_policy = StoragePolicy;
+            using mutex          = Mutex;
+            using is_stateful    = typename traits::is_stateful;
+
+            /// \effects Creates it by default-constructing the \c StoragePolicy.
+            /// \requires The \c StoragePolicy must be default-constructible.
+            /// \notes The default constructor may create an invalid allocator storage not associated with any allocator.
+            /// If that is the case, it must not be used.
+            allocator_storage() = default;
+
+            /// \effects Creates it by passing it an allocator.
+            /// The allocator will be forwarded to the \c StoragePolicy, it decides whether it will be moved, its address stored or something else.
+            /// \requires The expression <tt>new storage_policy(std::forward<Alloc>(alloc))</tt> must be well-formed,
+            /// otherwise this constructor does not participate in overload resolution.
+            template <
+                class Alloc,
+                // MSVC seems to ignore access rights in SFINAE below
+                // use this to prevent this constructor being chosen instead of move for types inheriting from it
+                WPI_REQUIRES(
+                    (!std::is_base_of<allocator_storage, typename std::decay<Alloc>::type>::value))>
+            allocator_storage(Alloc&& alloc,
+                              WPI_SFINAE(new storage_policy(detail::forward<Alloc>(alloc))))
+            : storage_policy(detail::forward<Alloc>(alloc))
+            {
+            }
+
+            /// \effects Creates it by passing it another \c allocator_storage with a different \c StoragePolicy but the same \c Mutex type.
+            /// Initializes it with the result of \c other.get_allocator().
+            /// \requires The expression <tt>new storage_policy(other.get_allocator())</tt> must be well-formed,
+            /// otherwise this constructor does not participate in overload resolution.
+            template <class OtherPolicy>
+            allocator_storage(const allocator_storage<OtherPolicy, Mutex>& other,
+                              WPI_SFINAE(new storage_policy(other.get_allocator())))
+            : storage_policy(other.get_allocator())
+            {
+            }
+
+            /// @{
+            /// \effects Moves the \c allocator_storage object.
+            /// A moved-out \c allocator_storage object must still store a valid allocator object.
+            allocator_storage(allocator_storage&& other) noexcept
+            : storage_policy(detail::move(other)),
+              detail::mutex_storage<
+                  detail::mutex_for<typename StoragePolicy::allocator_type, Mutex>>(
+                  detail::move(other))
+            {
+            }
+
+            allocator_storage& operator=(allocator_storage&& other) noexcept
+            {
+                storage_policy::                                 operator=(detail::move(other));
+                detail::mutex_storage<detail::mutex_for<typename StoragePolicy::allocator_type,
+                                                        Mutex>>::operator=(detail::move(other));
+                return *this;
+            }
+            /// @}
+
+            /// @{
+            /// \effects Copies the \c allocator_storage object.
+            /// \requires The \c StoragePolicy must be copyable.
+            allocator_storage(const allocator_storage&) = default;
+            allocator_storage& operator=(const allocator_storage&) = default;
+            /// @}
+
+            /// @{
+            /// \effects Calls the function on the stored allocator.
+            /// The \c Mutex will be locked during the operation.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return traits::allocate_node(alloc, size, alignment);
+            }
+
+            void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return traits::allocate_array(alloc, count, size, alignment);
+            }
+
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                traits::deallocate_node(alloc, ptr, size, alignment);
+            }
+
+            void deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                  std::size_t alignment) noexcept
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                traits::deallocate_array(alloc, ptr, count, size, alignment);
+            }
+
+            std::size_t max_node_size() const
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return traits::max_node_size(alloc);
+            }
+
+            std::size_t max_array_size() const
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return traits::max_array_size(alloc);
+            }
+
+            std::size_t max_alignment() const
+            {
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return traits::max_alignment(alloc);
+            }
+            /// @}
+
+            /// @{
+            /// \effects Calls the function on the stored composable allocator.
+            /// The \c Mutex will be locked during the operation.
+            /// \requires The allocator must be composable,
+            /// i.e. \ref is_composable() must return `true`.
+            /// \note This check is done at compile-time where possible,
+            /// and at runtime in the case of type-erased storage.
+            WPI_ENABLE_IF(composable::value)
+            void* try_allocate_node(std::size_t size, std::size_t alignment) noexcept
+            {
+                WPI_MEMORY_ASSERT(is_composable());
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return composable_traits::try_allocate_node(alloc, size, alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            void* try_allocate_array(std::size_t count, std::size_t size,
+                                     std::size_t alignment) noexcept
+            {
+                WPI_MEMORY_ASSERT(is_composable());
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return composable_traits::try_allocate_array(alloc, count, size, alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            bool try_deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                WPI_MEMORY_ASSERT(is_composable());
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return composable_traits::try_deallocate_node(alloc, ptr, size, alignment);
+            }
+
+            WPI_ENABLE_IF(composable::value)
+            bool try_deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                      std::size_t alignment) noexcept
+            {
+                WPI_MEMORY_ASSERT(is_composable());
+                std::lock_guard<actual_mutex> lock(*this);
+                auto&&                        alloc = get_allocator();
+                return composable_traits::try_deallocate_array(alloc, ptr, count, size, alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \effects Forwards to the \c StoragePolicy.
+            /// \returns Returns a reference to the stored allocator.
+            /// \note This does not lock the \c Mutex.
+            auto get_allocator() noexcept
+                -> decltype(std::declval<storage_policy>().get_allocator())
+            {
+                return storage_policy::get_allocator();
+            }
+
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<const storage_policy>().get_allocator())
+            {
+                return storage_policy::get_allocator();
+            }
+            /// @}
+
+            /// @{
+            /// \returns A proxy object that acts like a pointer to the stored allocator.
+            /// It cannot be reassigned to point to another allocator object and only moving is supported, which is destructive.
+            /// As long as the proxy object lives and is not moved from, the \c Mutex will be kept locked.
+            auto lock() noexcept -> WPI_IMPL_DEFINED(decltype(detail::lock_allocator(
+                std::declval<storage_policy>().get_allocator(), std::declval<actual_mutex&>())))
+            {
+                return detail::lock_allocator(get_allocator(), static_cast<actual_mutex&>(*this));
+            }
+
+            auto lock() const noexcept -> WPI_IMPL_DEFINED(decltype(
+                detail::lock_allocator(std::declval<const storage_policy>().get_allocator(),
+                                       std::declval<actual_mutex&>())))
+            {
+                return detail::lock_allocator(get_allocator(), static_cast<actual_mutex&>(*this));
+            }
+            /// @}.
+
+            /// \returns Whether or not the stored allocator is composable,
+            /// that is you can use the compositioning functions.
+            /// \note Due to type-erased allocators,
+            /// this function can not be `constexpr`.
+            bool is_composable() const noexcept
+            {
+                return StoragePolicy::is_composable();
+            }
+        };
+
+        /// Tag type that enables type-erasure in \ref reference_storage.
+        /// It can be used everywhere a \ref allocator_reference is used internally.
+        /// \ingroup storage
+        struct any_allocator
+        {
+        };
+
+        /// A \concept{concept_storagepolicy,StoragePolicy} that stores the allocator directly.
+        /// It embeds the allocator inside it, i.e. moving the storage policy will move the allocator.
+        /// \ingroup storage
+        template <class RawAllocator>
+        class direct_storage : WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+            static_assert(!std::is_same<RawAllocator, any_allocator>::value,
+                          "cannot type-erase in direct_storage");
+
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+
+            /// \effects Creates it by default-constructing the allocator.
+            /// \requires The \c RawAllcoator must be default constructible.
+            direct_storage() = default;
+
+            /// \effects Creates it by moving in an allocator object.
+            direct_storage(allocator_type&& allocator) noexcept
+            : allocator_type(detail::move(allocator))
+            {
+            }
+
+            /// @{
+            /// \effects Moves the \c direct_storage object.
+            /// This will move the stored allocator.
+            direct_storage(direct_storage&& other) noexcept : allocator_type(detail::move(other)) {}
+
+            direct_storage& operator=(direct_storage&& other) noexcept
+            {
+                allocator_type::operator=(detail::move(other));
+                return *this;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (\c const) reference to the stored allocator.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+        protected:
+            ~direct_storage() noexcept = default;
+
+            bool is_composable() const noexcept
+            {
+                return is_composable_allocator<allocator_type>::value;
+            }
+        };
+
+        /// An alias template for \ref allocator_storage using the \ref direct_storage policy without a mutex.
+        /// It has the effect of giving any \concept{concept_rawallocator,RawAllocator} the interface with all member functions,
+        /// avoiding the need to wrap it inside the \ref allocator_traits.
+        /// \ingroup storage
+        template <class RawAllocator>
+        WPI_ALIAS_TEMPLATE(allocator_adapter,
+                                 allocator_storage<direct_storage<RawAllocator>, no_mutex>);
+
+        /// \returns A new \ref allocator_adapter object created by forwarding to the constructor.
+        /// \relates allocator_adapter
+        template <class RawAllocator>
+        auto make_allocator_adapter(RawAllocator&& allocator) noexcept
+            -> allocator_adapter<typename std::decay<RawAllocator>::type>
+        {
+            return {detail::forward<RawAllocator>(allocator)};
+        }
+
+/// An alias template for \ref allocator_storage using the \ref direct_storage policy with a mutex.
+/// It has a similar effect as \ref allocator_adapter but performs synchronization.
+/// The \c Mutex will default to \c std::mutex if threading is supported,
+/// otherwise there is no default.
+/// \ingroup storage
+#if WPI_HOSTED_IMPLEMENTATION
+        template <class RawAllocator, class Mutex = std::mutex>
+        WPI_ALIAS_TEMPLATE(thread_safe_allocator,
+                                 allocator_storage<direct_storage<RawAllocator>, Mutex>);
+#else
+        template <class RawAllocator, class Mutex>
+        WPI_ALIAS_TEMPLATE(thread_safe_allocator,
+                                 allocator_storage<direct_storage<RawAllocator>, Mutex>);
+#endif
+
+#if WPI_HOSTED_IMPLEMENTATION
+        /// \returns A new \ref thread_safe_allocator object created by forwarding to the constructor/
+        /// \relates thread_safe_allocator
+        template <class RawAllocator>
+        auto make_thread_safe_allocator(RawAllocator&& allocator)
+            -> thread_safe_allocator<typename std::decay<RawAllocator>::type>
+        {
+            return detail::forward<RawAllocator>(allocator);
+        }
+#endif
+
+        /// \returns A new \ref thread_safe_allocator object created by forwarding to the constructor,
+        /// specifying a certain mutex type.
+        /// \requires It requires threading support from the implementation.
+        /// \relates thread_safe_allocator
+        template <class Mutex, class RawAllocator>
+        auto make_thread_safe_allocator(RawAllocator&& allocator)
+            -> thread_safe_allocator<typename std::decay<RawAllocator>::type, Mutex>
+        {
+            return detail::forward<RawAllocator>(allocator);
+        }
+
+        namespace detail
+        {
+            struct reference_stateful
+            {
+            };
+            struct reference_stateless
+            {
+            };
+            struct reference_shared
+            {
+            };
+
+            reference_stateful  reference_type(std::true_type stateful, std::false_type shared);
+            reference_stateless reference_type(std::false_type stateful, std::true_type shared);
+            reference_stateless reference_type(std::false_type stateful, std::false_type shared);
+            reference_shared    reference_type(std::true_type stateful, std::true_type shared);
+
+            template <class RawAllocator, class Tag>
+            class reference_storage_impl;
+
+            // reference to stateful: stores a pointer to an allocator
+            template <class RawAllocator>
+            class reference_storage_impl<RawAllocator, reference_stateful>
+            {
+            protected:
+                reference_storage_impl() noexcept : alloc_(nullptr) {}
+
+                reference_storage_impl(RawAllocator& allocator) noexcept : alloc_(&allocator) {}
+
+                bool is_valid() const noexcept
+                {
+                    return alloc_ != nullptr;
+                }
+
+                RawAllocator& get_allocator() const noexcept
+                {
+                    WPI_MEMORY_ASSERT(alloc_ != nullptr);
+                    return *alloc_;
+                }
+
+            private:
+                RawAllocator* alloc_;
+            };
+
+            // reference to stateless: store in static storage
+            template <class RawAllocator>
+            class reference_storage_impl<RawAllocator, reference_stateless>
+            {
+            protected:
+                reference_storage_impl() noexcept = default;
+
+                reference_storage_impl(const RawAllocator&) noexcept {}
+
+                bool is_valid() const noexcept
+                {
+                    return true;
+                }
+
+                RawAllocator& get_allocator() const noexcept
+                {
+                    static RawAllocator alloc;
+                    return alloc;
+                }
+            };
+
+            // reference to shared: stores RawAllocator directly
+            template <class RawAllocator>
+            class reference_storage_impl<RawAllocator, reference_shared>
+            {
+            protected:
+                reference_storage_impl() noexcept = default;
+
+                reference_storage_impl(const RawAllocator& alloc) noexcept : alloc_(alloc) {}
+
+                bool is_valid() const noexcept
+                {
+                    return true;
+                }
+
+                RawAllocator& get_allocator() const noexcept
+                {
+                    return alloc_;
+                }
+
+            private:
+                mutable RawAllocator alloc_;
+            };
+        } // namespace detail
+
+        /// Specifies whether or not a \concept{concept_rawallocator,RawAllocator} has shared semantics.
+        /// It is shared, if - like \ref allocator_reference - if multiple objects refer to the same internal allocator and if it can be copied.
+        /// This sharing is stateful, however, stateless allocators are not considered shared in the meaning of this traits. <br>
+        /// If a \c RawAllocator is shared, it will be directly embedded inside \ref reference_storage since it already provides \ref allocator_reference like semantics, so there is no need to add them manually,<br>
+        /// Specialize it for your own types, if they provide sharing semantics and can be copied.
+        /// They also must provide an `operator==` to check whether two allocators refer to the same shared one.
+        /// \note This makes no guarantees about the lifetime of the shared object, the sharing allocators can either own or refer to a shared object.
+        /// \ingroup storage
+        template <class RawAllocator>
+        struct is_shared_allocator : std::false_type
+        {
+        };
+
+        /// A \concept{concept_storagepolicy,StoragePolicy} that stores a reference to an allocator.
+        /// For stateful allocators it only stores a pointer to an allocator object and copying/moving only copies the pointer.
+        /// For stateless allocators it does not store anything, an allocator will be constructed as needed.
+        /// For allocators that are already shared (determined through \ref is_shared_allocator) it will store the allocator type directly.
+        /// \note It does not take ownership over the allocator in the stateful case, the user has to ensure that the allocator object stays valid.
+        /// In the other cases the lifetime does not matter.
+        /// \ingroup storage
+        template <class RawAllocator>
+        class reference_storage
+#ifndef DOXYGEN
+        : WPI_EBO(detail::reference_storage_impl<
+                        typename allocator_traits<RawAllocator>::allocator_type,
+                        decltype(detail::reference_type(
+                            typename allocator_traits<RawAllocator>::is_stateful{},
+                            is_shared_allocator<RawAllocator>{}))>)
+#endif
+        {
+            using storage = detail::reference_storage_impl<
+                typename allocator_traits<RawAllocator>::allocator_type,
+                decltype(
+                    detail::reference_type(typename allocator_traits<RawAllocator>::is_stateful{},
+                                           is_shared_allocator<RawAllocator>{}))>;
+
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+
+            /// Default constructor.
+            /// \effects If the allocator is stateless, this has no effect and the object is usable as an allocator.
+            /// If the allocator is stateful, creates an invalid reference without any associated allocator.
+            /// Then it must not be used.
+            /// If the allocator is shared, default constructs the shared allocator.
+            /// If the shared allocator does not have a default constructor, this constructor is ill-formed.
+            reference_storage() noexcept = default;
+
+            /// \effects Creates it from a stateless or shared allocator.
+            /// It will not store anything, only creates the allocator as needed.
+            /// \requires The \c RawAllocator is stateless or shared.
+            reference_storage(const allocator_type& alloc) noexcept : storage(alloc) {}
+
+            /// \effects Creates it from a reference to a stateful allocator.
+            /// It will store a pointer to this allocator object.
+            /// \note The user has to take care that the lifetime of the reference does not exceed the allocator lifetime.
+            reference_storage(allocator_type& alloc) noexcept : storage(alloc) {}
+
+            /// @{
+            /// \effects Copies the \c allocator_reference object.
+            /// Only copies the pointer to it in the stateful case.
+            reference_storage(const reference_storage&) noexcept = default;
+            reference_storage& operator=(const reference_storage&) noexcept = default;
+            /// @}
+
+            /// \returns Whether or not the reference is valid.
+            /// It is only invalid, if it was created by the default constructor and the allocator is stateful.
+            explicit operator bool() const noexcept
+            {
+                return storage::is_valid();
+            }
+
+            /// \returns Returns a reference to the allocator.
+            /// \requires The reference must be valid.
+            allocator_type& get_allocator() const noexcept
+            {
+                return storage::get_allocator();
+            }
+
+        protected:
+            ~reference_storage() noexcept = default;
+
+            bool is_composable() const noexcept
+            {
+                return is_composable_allocator<allocator_type>::value;
+            }
+        };
+
+        /// Specialization of the class template \ref reference_storage that is type-erased.
+        /// It is triggered by the tag type \ref any_allocator.
+        /// The specialization can store a reference to any allocator type.
+        /// \ingroup storage
+        template <>
+        class reference_storage<any_allocator>
+        {
+            class base_allocator
+            {
+            public:
+                using is_stateful = std::true_type;
+
+                virtual ~base_allocator() = default;
+
+                virtual void clone(void* storage) const noexcept = 0;
+
+                void* allocate_node(std::size_t size, std::size_t alignment)
+                {
+                    return allocate_impl(1, size, alignment);
+                }
+
+                void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+                {
+                    return allocate_impl(count, size, alignment);
+                }
+
+                void deallocate_node(void* node, std::size_t size, std::size_t alignment) noexcept
+                {
+                    deallocate_impl(node, 1, size, alignment);
+                }
+
+                void deallocate_array(void* array, std::size_t count, std::size_t size,
+                                      std::size_t alignment) noexcept
+                {
+                    deallocate_impl(array, count, size, alignment);
+                }
+
+                void* try_allocate_node(std::size_t size, std::size_t alignment) noexcept
+                {
+                    return try_allocate_impl(1, size, alignment);
+                }
+
+                void* try_allocate_array(std::size_t count, std::size_t size,
+                                         std::size_t alignment) noexcept
+                {
+                    return try_allocate_impl(count, size, alignment);
+                }
+
+                bool try_deallocate_node(void* node, std::size_t size,
+                                         std::size_t alignment) noexcept
+                {
+                    return try_deallocate_impl(node, 1, size, alignment);
+                }
+
+                bool try_deallocate_array(void* array, std::size_t count, std::size_t size,
+                                          std::size_t alignment) noexcept
+                {
+                    return try_deallocate_impl(array, count, size, alignment);
+                }
+
+                // count 1 means node
+                virtual void* allocate_impl(std::size_t count, std::size_t size,
+                                            std::size_t alignment)            = 0;
+                virtual void  deallocate_impl(void* ptr, std::size_t count, std::size_t size,
+                                              std::size_t alignment) noexcept = 0;
+
+                virtual void* try_allocate_impl(std::size_t count, std::size_t size,
+                                                std::size_t alignment) noexcept = 0;
+
+                virtual bool try_deallocate_impl(void* ptr, std::size_t count, std::size_t size,
+                                                 std::size_t alignment) noexcept = 0;
+
+                std::size_t max_node_size() const
+                {
+                    return max(query::node_size);
+                }
+
+                std::size_t max_array_size() const
+                {
+                    return max(query::array_size);
+                }
+
+                std::size_t max_alignment() const
+                {
+                    return max(query::alignment);
+                }
+
+                virtual bool is_composable() const noexcept = 0;
+
+            protected:
+                enum class query
+                {
+                    node_size,
+                    array_size,
+                    alignment
+                };
+
+                virtual std::size_t max(query q) const = 0;
+            };
+
+        public:
+            using allocator_type = WPI_IMPL_DEFINED(base_allocator);
+
+            /// \effects Creates it from a reference to any stateful \concept{concept_rawallocator,RawAllocator}.
+            /// It will store a pointer to this allocator object.
+            /// \note The user has to take care that the lifetime of the reference does not exceed the allocator lifetime.
+            template <class RawAllocator>
+            reference_storage(RawAllocator& alloc) noexcept
+            {
+                static_assert(sizeof(basic_allocator<RawAllocator>)
+                                  <= sizeof(basic_allocator<default_instantiation>),
+                              "requires all instantiations to have certain maximum size");
+                ::new (static_cast<void*>(&storage_)) basic_allocator<RawAllocator>(alloc);
+            }
+
+            // \effects Creates it from any stateless \concept{concept_rawallocator,RawAllocator}.
+            /// It will not store anything, only creates the allocator as needed.
+            /// \requires The \c RawAllocator is stateless.
+            template <class RawAllocator>
+            reference_storage(
+                const RawAllocator& alloc,
+                WPI_REQUIRES(!allocator_traits<RawAllocator>::is_stateful::value)) noexcept
+            {
+                static_assert(sizeof(basic_allocator<RawAllocator>)
+                                  <= sizeof(basic_allocator<default_instantiation>),
+                              "requires all instantiations to have certain maximum size");
+                ::new (static_cast<void*>(&storage_)) basic_allocator<RawAllocator>(alloc);
+            }
+
+            /// \effects Creates it from the internal base class for the type-erasure.
+            /// Has the same effect as if the actual stored allocator were passed to the other constructor overloads.
+            /// \note This constructor is used internally to avoid double-nesting.
+            reference_storage(const WPI_IMPL_DEFINED(base_allocator) & alloc) noexcept
+            {
+                alloc.clone(&storage_);
+            }
+
+            /// \effects Creates it from the internal base class for the type-erasure.
+            /// Has the same effect as if the actual stored allocator were passed to the other constructor overloads.
+            /// \note This constructor is used internally to avoid double-nesting.
+            reference_storage(WPI_IMPL_DEFINED(base_allocator) & alloc) noexcept
+            : reference_storage(static_cast<const base_allocator&>(alloc))
+            {
+            }
+
+            /// @{
+            /// \effects Copies the \c reference_storage object.
+            /// It only copies the pointer to the allocator.
+            reference_storage(const reference_storage& other) noexcept
+            {
+                other.get_allocator().clone(&storage_);
+            }
+
+            reference_storage& operator=(const reference_storage& other) noexcept
+            {
+                get_allocator().~allocator_type();
+                other.get_allocator().clone(&storage_);
+                return *this;
+            }
+            /// @}
+
+            /// \returns A reference to the allocator.
+            /// The actual type is implementation-defined since it is the base class used in the type-erasure,
+            /// but it provides the full \concept{concept_rawallocator,RawAllocator} member functions.
+            /// \note There is no way to access any custom member functions of the allocator type.
+            allocator_type& get_allocator() const noexcept
+            {
+                auto mem = static_cast<void*>(&storage_);
+                return *static_cast<base_allocator*>(mem);
+            }
+
+        protected:
+            ~reference_storage() noexcept
+            {
+                get_allocator().~allocator_type();
+            }
+
+            bool is_composable() const noexcept
+            {
+                return get_allocator().is_composable();
+            }
+
+        private:
+            template <class RawAllocator>
+            class basic_allocator
+            : public base_allocator,
+              private detail::reference_storage_impl<
+                  typename allocator_traits<RawAllocator>::allocator_type,
+                  decltype(
+                      detail::reference_type(typename allocator_traits<RawAllocator>::is_stateful{},
+                                             is_shared_allocator<RawAllocator>{}))>
+            {
+                using traits     = allocator_traits<RawAllocator>;
+                using composable = is_composable_allocator<typename traits::allocator_type>;
+                using storage    = detail::reference_storage_impl<
+                    typename allocator_traits<RawAllocator>::allocator_type,
+                    decltype(detail::reference_type(typename allocator_traits<
+                                                        RawAllocator>::is_stateful{},
+                                                    is_shared_allocator<RawAllocator>{}))>;
+
+            public:
+                // non stateful
+                basic_allocator(const RawAllocator& alloc) noexcept : storage(alloc) {}
+
+                // stateful
+                basic_allocator(RawAllocator& alloc) noexcept : storage(alloc) {}
+
+            private:
+                typename traits::allocator_type& get() const noexcept
+                {
+                    return storage::get_allocator();
+                }
+
+                void clone(void* storage) const noexcept override
+                {
+                    ::new (storage) basic_allocator(get());
+                }
+
+                void* allocate_impl(std::size_t count, std::size_t size,
+                                    std::size_t alignment) override
+                {
+                    auto&& alloc = get();
+                    if (count == 1u)
+                        return traits::allocate_node(alloc, size, alignment);
+                    else
+                        return traits::allocate_array(alloc, count, size, alignment);
+                }
+
+                void deallocate_impl(void* ptr, std::size_t count, std::size_t size,
+                                     std::size_t alignment) noexcept override
+                {
+                    auto&& alloc = get();
+                    if (count == 1u)
+                        traits::deallocate_node(alloc, ptr, size, alignment);
+                    else
+                        traits::deallocate_array(alloc, ptr, count, size, alignment);
+                }
+
+                void* try_allocate_impl(std::size_t count, std::size_t size,
+                                        std::size_t alignment) noexcept override
+                {
+                    auto&& alloc = get();
+                    if (count == 1u)
+                        return detail::try_allocate_node(composable{}, alloc, size, alignment);
+                    else
+                        return detail::try_allocate_array(composable{}, alloc, count, size,
+                                                          alignment);
+                }
+
+                bool try_deallocate_impl(void* ptr, std::size_t count, std::size_t size,
+                                         std::size_t alignment) noexcept override
+                {
+                    auto&& alloc = get();
+                    if (count == 1u)
+                        return detail::try_deallocate_node(composable{}, alloc, ptr, size,
+                                                           alignment);
+                    else
+                        return detail::try_deallocate_array(composable{}, alloc, ptr, count, size,
+                                                            alignment);
+                }
+
+                bool is_composable() const noexcept override
+                {
+                    return composable::value;
+                }
+
+                std::size_t max(query q) const override
+                {
+                    auto&& alloc = get();
+                    if (q == query::node_size)
+                        return traits::max_node_size(alloc);
+                    else if (q == query::array_size)
+                        return traits::max_array_size(alloc);
+                    return traits::max_alignment(alloc);
+                }
+            };
+
+            // use a stateful instantiation to determine size and alignment
+            // base_allocator is stateful
+            using default_instantiation = basic_allocator<base_allocator>;
+            alignas(default_instantiation) mutable char storage_[sizeof(default_instantiation)];
+        };
+
+        /// An alias template for \ref allocator_storage using the \ref reference_storage policy.
+        /// It will store a reference to the given allocator type. The tag type \ref any_allocator enables type-erasure.
+        /// Wrap the allocator in a \ref thread_safe_allocator if you want thread safety.
+        /// \ingroup storage
+        template <class RawAllocator>
+        WPI_ALIAS_TEMPLATE(allocator_reference,
+                                 allocator_storage<reference_storage<RawAllocator>, no_mutex>);
+
+        /// \returns A new \ref allocator_reference object by forwarding the allocator to the constructor.
+        /// \relates allocator_reference
+        template <class RawAllocator>
+        auto make_allocator_reference(RawAllocator&& allocator) noexcept
+            -> allocator_reference<typename std::decay<RawAllocator>::type>
+        {
+            return {detail::forward<RawAllocator>(allocator)};
+        }
+
+        /// An alias for the \ref reference_storage specialization using type-erasure.
+        /// \ingroup storage
+        using any_reference_storage = reference_storage<any_allocator>;
+
+        /// An alias for \ref allocator_storage using the \ref any_reference_storage.
+        /// It will store a reference to any \concept{concept_rawallocator,RawAllocator}.
+        /// This is the same as passing the tag type \ref any_allocator to the alias \ref allocator_reference.
+        /// Wrap the allocator in a \ref thread_safe_allocator if you want thread safety.
+        /// \ingroup storage
+        using any_allocator_reference = allocator_storage<any_reference_storage, no_mutex>;
+
+        /// \returns A new \ref any_allocator_reference object by forwarding the allocator to the constructor.
+        /// \relates any_allocator_reference
+        template <class RawAllocator>
+        auto make_any_allocator_reference(RawAllocator&& allocator) noexcept
+            -> any_allocator_reference
+        {
+            return {detail::forward<RawAllocator>(allocator)};
+        }
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_ALLOCATOR_STORAGE_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_traits.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_traits.hpp
new file mode 100644
index 0000000..47b6ffb
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/allocator_traits.hpp
@@ -0,0 +1,603 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_ALLOCATOR_TRAITS_HPP_INCLUDED
+#define WPI_MEMORY_ALLOCATOR_TRAITS_HPP_INCLUDED
+
+/// \file
+/// The default specialization of the \ref wpi::memory::allocator_traits.
+
+#include <cstddef>
+#include <type_traits>
+
+#include "detail/align.hpp"
+#include "detail/utility.hpp"
+#include "config.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <memory>
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <class Allocator>
+            std::true_type has_construct(int, WPI_SFINAE(std::declval<Allocator>().construct(
+                                                  std::declval<typename Allocator::pointer>(),
+                                                  std::declval<typename Allocator::value_type>())));
+
+            template <class Allocator>
+            std::false_type has_construct(short);
+
+            template <class Allocator>
+            std::true_type has_destroy(int, WPI_SFINAE(std::declval<Allocator>().destroy(
+                                                std::declval<typename Allocator::pointer>())));
+
+            template <class Allocator>
+            std::false_type has_destroy(short);
+
+            template <class Allocator>
+            struct check_standard_allocator
+            {
+                using custom_construct = decltype(has_construct<Allocator>(0));
+                using custom_destroy   = decltype(has_destroy<Allocator>(0));
+
+                using valid = std::integral_constant<bool, !custom_construct::value
+                                                               && !custom_destroy::value>;
+            };
+        } // namespace detail
+
+        /// Traits class that checks whether or not a standard \c Allocator can be used as \concept{concept_rawallocator,RawAllocator}.
+        /// It checks the existence of a custom \c construct(), \c destroy() function, if provided,
+        /// it cannot be used since it would not be called.<br>
+        /// Specialize it for custom \c Allocator types to override this check.
+        /// \ingroup core
+        template <class Allocator>
+        struct allocator_is_raw_allocator
+        : WPI_EBO(detail::check_standard_allocator<Allocator>::valid)
+        {
+        };
+
+        /// Specialization of \ref allocator_is_raw_allocator that allows \c std::allocator again.
+        /// \ingroup core
+        template <typename T>
+        struct allocator_is_raw_allocator<std::allocator<T>> : std::true_type
+        {
+        };
+
+        namespace traits_detail // use seperate namespace to avoid name clashes
+        {
+            // full_concept has the best conversion rank, error the lowest
+            // used to give priority to the functions
+            struct error
+            {
+                operator void*() const noexcept
+                {
+                    WPI_MEMORY_UNREACHABLE(
+                        "this is just to hide an error and move static_assert to the front");
+                    return nullptr;
+                }
+            };
+            struct std_concept : error
+            {
+            };
+            struct min_concept : std_concept
+            {
+            };
+            struct full_concept : min_concept
+            {
+            };
+
+            // used to delay assert in handle_error() until instantiation
+            template <typename T>
+            struct invalid_allocator_concept
+            {
+                static const bool error = false;
+            };
+
+            //=== allocator_type ===//
+            // if Allocator has a member template `rebind`, use that to rebind to `char`
+            // else if Allocator has a member `value_type`, rebind by changing argument
+            // else does nothing
+            template <class Allocator>
+            auto rebind_impl(int) -> typename Allocator::template rebind<char>::other&;
+
+            template <class Allocator, typename T>
+            struct allocator_rebinder
+            {
+                using type = Allocator&;
+            };
+
+            template <template <typename, typename...> class Alloc, typename U, typename... Args,
+                      typename T>
+            struct allocator_rebinder<Alloc<U, Args...>, T>
+            {
+                using type = Alloc<T, Args...>&;
+            };
+
+            template <class Allocator, typename = typename Allocator::value_type>
+            auto rebind_impl(char) -> typename allocator_rebinder<Allocator, char>::type;
+
+            template <class Allocator>
+            auto rebind_impl(...) -> Allocator&;
+
+            template <class Allocator>
+            struct allocator_type_impl // required for MSVC
+            {
+                using type = decltype(rebind_impl<Allocator>(0));
+            };
+
+            template <class Allocator>
+            using allocator_type =
+                typename std::decay<typename allocator_type_impl<Allocator>::type>::type;
+
+            //=== is_stateful ===//
+            // first try to access Allocator::is_stateful,
+            // then use whether or not the type is empty
+            template <class Allocator>
+            auto is_stateful(full_concept) -> decltype(typename Allocator::is_stateful{});
+
+            template <class Allocator, bool IsEmpty>
+            struct is_stateful_impl;
+
+            template <class Allocator>
+            struct is_stateful_impl<Allocator, true>
+            {
+                static_assert(std::is_default_constructible<Allocator>::value,
+                              "RawAllocator is empty but not default constructible ."
+                              "This means it is not a stateless allocator. "
+                              "If this is actually intended provide the appropriate is_stateful "
+                              "typedef in your class.");
+                using type = std::false_type;
+            };
+
+            template <class Allocator>
+            struct is_stateful_impl<Allocator, false>
+            {
+                using type = std::true_type;
+            };
+
+            template <class Allocator>
+            auto is_stateful(min_concept) ->
+                typename is_stateful_impl<Allocator, std::is_empty<Allocator>::value>::type;
+
+            //=== allocate_node() ===//
+            // first try Allocator::allocate_node
+            // then assume std_allocator and call Allocator::allocate
+            // then error
+            template <class Allocator>
+            auto allocate_node(full_concept, Allocator& alloc, std::size_t size,
+                               std::size_t alignment)
+                -> WPI_AUTO_RETURN_TYPE(alloc.allocate_node(size, alignment), void*)
+
+                    template <class Allocator>
+                    auto allocate_node(std_concept, Allocator& alloc, std::size_t size, std::size_t)
+                        -> WPI_AUTO_RETURN(static_cast<void*>(alloc.allocate(size)))
+
+                            template <class Allocator>
+                            error allocate_node(error, Allocator&, std::size_t, std::size_t)
+            {
+                static_assert(invalid_allocator_concept<Allocator>::error,
+                              "type is not a RawAllocator as it does not provide: void* "
+                              "allocate_node(std::size_t, "
+                              "std::size_t)");
+                return {};
+            }
+
+            //=== deallocate_node() ===//
+            // first try Allocator::deallocate_node
+            // then assume std_allocator and call Allocator::deallocate
+            // then error
+            template <class Allocator>
+            auto deallocate_node(full_concept, Allocator& alloc, void* ptr, std::size_t size,
+                                 std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_node(ptr, size, alignment), void)
+
+                    template <class Allocator>
+                    auto deallocate_node(std_concept, Allocator& alloc, void* ptr, std::size_t size,
+                                         std::size_t) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.deallocate(static_cast<char*>(ptr), size), void)
+
+                    template <class Allocator>
+                    error deallocate_node(error, Allocator&, void*, std::size_t, std::size_t)
+            {
+                static_assert(invalid_allocator_concept<Allocator>::error,
+                              "type is not a RawAllocator as it does not provide: void "
+                              "deallocate_node(void*, std::size_t, "
+                              "std::size_t)");
+                return error{};
+            }
+
+            //=== allocate_array() ===//
+            // first try Allocator::allocate_array
+            // then forward to allocate_node()
+            template <class Allocator>
+            auto allocate_array(full_concept, Allocator& alloc, std::size_t count, std::size_t size,
+                                std::size_t alignment)
+                -> WPI_AUTO_RETURN_TYPE(alloc.allocate_array(count, size, alignment), void*)
+
+                    template <class Allocator>
+                    void* allocate_array(min_concept, Allocator& alloc, std::size_t count,
+                                         std::size_t size, std::size_t alignment)
+            {
+                return allocate_node(full_concept{}, alloc, count * size, alignment);
+            }
+
+            //=== deallocate_array() ===//
+            // first try Allocator::deallocate_array
+            // then forward to deallocate_node()
+            template <class Allocator>
+            auto deallocate_array(full_concept, Allocator& alloc, void* ptr, std::size_t count,
+                                  std::size_t size, std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_array(ptr, count, size, alignment),
+                                              void)
+
+                    template <class Allocator>
+                    void deallocate_array(min_concept, Allocator& alloc, void* ptr,
+                                          std::size_t count, std::size_t size,
+                                          std::size_t alignment) noexcept
+            {
+                deallocate_node(full_concept{}, alloc, ptr, count * size, alignment);
+            }
+
+            //=== max_node_size() ===//
+            // first try Allocator::max_node_size()
+            // then return maximum value
+            template <class Allocator>
+            auto max_node_size(full_concept, const Allocator& alloc)
+                -> WPI_AUTO_RETURN_TYPE(alloc.max_node_size(), std::size_t)
+
+                    template <class Allocator>
+                    std::size_t max_node_size(min_concept, const Allocator&) noexcept
+            {
+                return std::size_t(-1);
+            }
+
+            //=== max_node_size() ===//
+            // first try Allocator::max_array_size()
+            // then forward to max_node_size()
+            template <class Allocator>
+            auto max_array_size(full_concept, const Allocator& alloc)
+                -> WPI_AUTO_RETURN_TYPE(alloc.max_array_size(), std::size_t)
+
+                    template <class Allocator>
+                    std::size_t max_array_size(min_concept, const Allocator& alloc)
+            {
+                return max_node_size(full_concept{}, alloc);
+            }
+
+            //=== max_alignment() ===//
+            // first try Allocator::max_alignment()
+            // then return detail::max_alignment
+            template <class Allocator>
+            auto max_alignment(full_concept, const Allocator& alloc)
+                -> WPI_AUTO_RETURN_TYPE(alloc.max_alignment(), std::size_t)
+
+                    template <class Allocator>
+                    std::size_t max_alignment(min_concept, const Allocator&)
+            {
+                return detail::max_alignment;
+            }
+        } // namespace traits_detail
+
+        /// The default specialization of the allocator_traits for a \concept{concept_rawallocator,RawAllocator}.
+        /// See the last link for the requirements on types that do not specialize this class and the interface documentation.
+        /// Any specialization must provide the same interface.
+        /// \ingroup core
+        template <class Allocator>
+        class allocator_traits
+        {
+        public:
+            using allocator_type = traits_detail::allocator_type<Allocator>;
+            using is_stateful =
+                decltype(traits_detail::is_stateful<Allocator>(traits_detail::full_concept{}));
+
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                return traits_detail::allocate_node(traits_detail::full_concept{}, state, size,
+                                                    alignment);
+            }
+
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                return traits_detail::allocate_array(traits_detail::full_concept{}, state, count,
+                                                     size, alignment);
+            }
+
+            static void deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                        std::size_t alignment) noexcept
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                traits_detail::deallocate_node(traits_detail::full_concept{}, state, node, size,
+                                               alignment);
+            }
+
+            static void deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                         std::size_t size, std::size_t alignment) noexcept
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                traits_detail::deallocate_array(traits_detail::full_concept{}, state, array, count,
+                                                size, alignment);
+            }
+
+            static std::size_t max_node_size(const allocator_type& state)
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                return traits_detail::max_node_size(traits_detail::full_concept{}, state);
+            }
+
+            static std::size_t max_array_size(const allocator_type& state)
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                return traits_detail::max_array_size(traits_detail::full_concept{}, state);
+            }
+
+            static std::size_t max_alignment(const allocator_type& state)
+            {
+                static_assert(allocator_is_raw_allocator<Allocator>::value,
+                              "Allocator cannot be used as RawAllocator because it provides custom "
+                              "construct()/destroy()");
+                return traits_detail::max_alignment(traits_detail::full_concept{}, state);
+            }
+
+#if !defined(DOXYGEN)
+            using foonathan_memory_default_traits = std::true_type;
+#endif
+        };
+
+        namespace detail
+        {
+            template <class RawAllocator>
+            typename allocator_traits<RawAllocator>::foonathan_memory_default_traits
+                alloc_uses_default_traits(RawAllocator&);
+
+            std::false_type alloc_uses_default_traits(...);
+
+            template <typename T>
+            struct has_invalid_alloc_function
+            : std::is_same<decltype(
+                               traits_detail::allocate_node(traits_detail::full_concept{},
+                                                            std::declval<typename allocator_traits<
+                                                                T>::allocator_type&>(),
+                                                            0, 0)),
+                           traits_detail::error>
+            {
+            };
+
+            template <typename T>
+            struct has_invalid_dealloc_function
+            : std::is_same<
+                  decltype(traits_detail::deallocate_node(traits_detail::full_concept{},
+                                                          std::declval<typename allocator_traits<
+                                                              T>::allocator_type&>(),
+                                                          nullptr, 0, 0)),
+                  traits_detail::error>
+            {
+            };
+
+            template <typename T, class DefaultTraits>
+            struct is_raw_allocator : std::true_type
+            {
+            };
+
+            template <typename T>
+            struct is_raw_allocator<T, std::integral_constant<bool, true>>
+            : std::integral_constant<bool, allocator_is_raw_allocator<T>::value
+                                               && !(has_invalid_alloc_function<T>::value
+                                                    || has_invalid_dealloc_function<T>::value)>
+            {
+            };
+        } // namespace detail
+
+        /// Traits that check whether a type models concept \concept{concept_rawallocator,RawAllocator}.<br>
+        /// It must either provide the necessary functions for the default traits specialization or has specialized it.
+        /// \ingroup core
+        template <typename T>
+        struct is_raw_allocator
+        : detail::is_raw_allocator<T,
+                                   decltype(detail::alloc_uses_default_traits(std::declval<T&>()))>
+        {
+        };
+
+        namespace traits_detail
+        {
+            //=== try_allocate_node() ===//
+            // try Allocator::try_allocate_node
+            // otherwise error
+            template <class Allocator>
+            auto try_allocate_node(full_concept, Allocator& alloc, std::size_t size,
+                                   std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_node(size, alignment), void*)
+
+                    template <class Allocator>
+                    error try_allocate_node(error, Allocator&, std::size_t, std::size_t)
+            {
+                static_assert(invalid_allocator_concept<Allocator>::error,
+                              "type is not a composable RawAllocator as it does not provide: void* "
+                              "try_allocate_node(std::size_t, "
+                              "std::size_t)");
+                return {};
+            }
+
+            //=== try_deallocate_node() ===//
+            // try Allocator::try_deallocate_node
+            // otherwise error
+            template <class Allocator>
+            auto try_deallocate_node(full_concept, Allocator& alloc, void* ptr, std::size_t size,
+                                     std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_node(ptr, size, alignment), bool)
+
+                    template <class Allocator>
+                    error try_deallocate_node(error, Allocator&, void*, std::size_t, std::size_t)
+            {
+                static_assert(invalid_allocator_concept<Allocator>::error,
+                              "type is not a composable RawAllocator as it does not provide: bool "
+                              "try_deallocate_node(void*, std::size_t, "
+                              "std::size_t)");
+                return error{};
+            }
+
+            //=== try_allocate_array() ===//
+            // first try Allocator::try_allocate_array
+            // then forward to try_allocate_node()
+            template <class Allocator>
+            auto try_allocate_array(full_concept, Allocator& alloc, std::size_t count,
+                                    std::size_t size, std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_array(count, size, alignment),
+                                              void*)
+
+                    template <class Allocator>
+                    void* try_allocate_array(min_concept, Allocator& alloc, std::size_t count,
+                                             std::size_t size, std::size_t alignment)
+            {
+                return try_allocate_node(full_concept{}, alloc, count * size, alignment);
+            }
+
+            //=== try_deallocate_array() ===//
+            // first try Allocator::try_deallocate_array
+            // then forward to try_deallocate_node()
+            template <class Allocator>
+            auto try_deallocate_array(full_concept, Allocator& alloc, void* ptr, std::size_t count,
+                                      std::size_t size, std::size_t alignment) noexcept
+                -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_array(ptr, count, size,
+                                                                         alignment),
+                                              bool)
+
+                    template <class Allocator>
+                    bool try_deallocate_array(min_concept, Allocator& alloc, void* ptr,
+                                              std::size_t count, std::size_t size,
+                                              std::size_t alignment) noexcept
+            {
+                return try_deallocate_node(full_concept{}, alloc, ptr, count * size, alignment);
+            }
+        } // namespace traits_detail
+
+        /// The default specialization of the composable_allocator_traits for a \concept{concept_composableallocator,ComposableAllocator}.
+        /// See the last link for the requirements on types that do not specialize this class and the interface documentation.
+        /// Any specialization must provide the same interface.
+        /// \ingroup core
+        template <class Allocator>
+        class composable_allocator_traits
+        {
+        public:
+            using allocator_type = typename allocator_traits<Allocator>::allocator_type;
+
+            static void* try_allocate_node(allocator_type& state, std::size_t size,
+                                           std::size_t alignment) noexcept
+            {
+                static_assert(is_raw_allocator<Allocator>::value,
+                              "ComposableAllocator must be RawAllocator");
+                return traits_detail::try_allocate_node(traits_detail::full_concept{}, state, size,
+                                                        alignment);
+            }
+
+            static void* try_allocate_array(allocator_type& state, std::size_t count,
+                                            std::size_t size, std::size_t alignment) noexcept
+            {
+                static_assert(is_raw_allocator<Allocator>::value,
+                              "ComposableAllocator must be RawAllocator");
+                return traits_detail::try_allocate_array(traits_detail::full_concept{}, state,
+                                                         count, size, alignment);
+            }
+
+            static bool try_deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                            std::size_t alignment) noexcept
+            {
+                static_assert(is_raw_allocator<Allocator>::value,
+                              "ComposableAllocator must be RawAllocator");
+                return traits_detail::try_deallocate_node(traits_detail::full_concept{}, state,
+                                                          node, size, alignment);
+            }
+
+            static bool try_deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                             std::size_t size, std::size_t alignment) noexcept
+            {
+                static_assert(is_raw_allocator<Allocator>::value,
+                              "ComposableAllocator must be RawAllocator");
+                return traits_detail::try_deallocate_array(traits_detail::full_concept{}, state,
+                                                           array, count, size, alignment);
+            }
+
+#if !defined(DOXYGEN)
+            using foonathan_memory_default_traits = std::true_type;
+#endif
+        };
+
+        namespace detail
+        {
+            template <class RawAllocator>
+            typename composable_allocator_traits<RawAllocator>::foonathan_memory_default_traits
+                composable_alloc_uses_default_traits(RawAllocator&);
+
+            std::false_type composable_alloc_uses_default_traits(...);
+
+            template <typename T>
+            struct has_invalid_try_alloc_function
+            : std::is_same<
+                  decltype(traits_detail::try_allocate_node(traits_detail::full_concept{},
+                                                            std::declval<typename allocator_traits<
+                                                                T>::allocator_type&>(),
+                                                            0, 0)),
+                  traits_detail::error>
+            {
+            };
+
+            template <typename T>
+            struct has_invalid_try_dealloc_function
+            : std::is_same<
+                  decltype(
+                      traits_detail::try_deallocate_node(traits_detail::full_concept{},
+                                                         std::declval<typename allocator_traits<
+                                                             T>::allocator_type&>(),
+                                                         nullptr, 0, 0)),
+                  traits_detail::error>
+            {
+            };
+
+            template <typename T, class DefaultTraits>
+            struct is_composable_allocator : memory::is_raw_allocator<T>
+            {
+            };
+
+            template <typename T>
+            struct is_composable_allocator<T, std::integral_constant<bool, true>>
+            : std::integral_constant<bool, memory::is_raw_allocator<T>::value
+                                               && !(has_invalid_try_alloc_function<T>::value
+                                                    || has_invalid_try_dealloc_function<T>::value)>
+            {
+            };
+        } // namespace detail
+
+        /// Traits that check whether a type models concept \concept{concept_rawallocator,ComposableAllocator}.<br>
+        /// It must be a \concept{concept_rawallocator,RawAllocator} and either provide the necessary functions for the default traits specialization or has specialized it.
+        /// \ingroup core
+        template <typename T>
+        struct is_composable_allocator
+        : detail::is_composable_allocator<T, decltype(detail::composable_alloc_uses_default_traits(
+                                                 std::declval<T&>()))>
+        {
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_ALLOCATOR_TRAITS_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config.hpp
new file mode 100644
index 0000000..067ecd2
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config.hpp
@@ -0,0 +1,148 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+/// \file
+/// Configuration macros.
+
+#ifndef WPI_MEMORY_CONFIG_HPP_INCLUDED
+#define WPI_MEMORY_CONFIG_HPP_INCLUDED
+
+#include <cstddef>
+
+#if !defined(DOXYGEN)
+#define WPI_MEMORY_IMPL_IN_CONFIG_HPP
+#include "config_impl.hpp"
+#undef WPI_MEMORY_IMPL_IN_CONFIG_HPP
+#endif
+
+// exception support
+#ifndef WPI_HAS_EXCEPTION_SUPPORT
+#if defined(__GNUC__) && !defined(__EXCEPTIONS)
+#define WPI_HAS_EXCEPTION_SUPPORT 0
+#elif defined(_MSC_VER) && !_HAS_EXCEPTIONS
+#define WPI_HAS_EXCEPTION_SUPPORT 0
+#else
+#define WPI_HAS_EXCEPTION_SUPPORT 1
+#endif
+#endif
+
+#if WPI_HAS_EXCEPTION_SUPPORT
+#define WPI_THROW(Ex) throw(Ex)
+#else
+#include <cstdlib>
+#define WPI_THROW(Ex) ((Ex), std::abort())
+#endif
+
+// hosted implementation
+#ifndef WPI_HOSTED_IMPLEMENTATION
+#if !_MSC_VER && !__STDC_HOSTED__
+#define WPI_HOSTED_IMPLEMENTATION 0
+#else
+#define WPI_HOSTED_IMPLEMENTATION 1
+#endif
+#endif
+
+// log prefix
+#define WPI_MEMORY_LOG_PREFIX "wpi::memory"
+
+// version
+#define WPI_MEMORY_VERSION                                                                   \
+    (WPI_MEMORY_VERSION_MAJOR * 100 + WPI_MEMORY_VERSION_MINOR)
+
+// use this macro to mark implementation-defined types
+// gives it more semantics and useful with doxygen
+// add PREDEFINED: WPI_IMPL_DEFINED():=implementation_defined
+#ifndef WPI_IMPL_DEFINED
+#define WPI_IMPL_DEFINED(...) __VA_ARGS__
+#endif
+
+// use this macro to mark base class which only purpose is EBO
+// gives it more semantics and useful with doxygen
+// add PREDEFINED: WPI_EBO():=
+#ifndef WPI_EBO
+#define WPI_EBO(...) __VA_ARGS__
+#endif
+
+#ifndef WPI_ALIAS_TEMPLATE
+// defines a template alias
+// usage:
+// template <typename T>
+// WPI_ALIAS_TEMPLATE(bar, foo<T, int>);
+// useful for doxygen
+#ifdef DOXYGEN
+#define WPI_ALIAS_TEMPLATE(Name, ...)                                                        \
+    class Name : public __VA_ARGS__                                                                \
+    {                                                                                              \
+    }
+#else
+#define WPI_ALIAS_TEMPLATE(Name, ...) using Name = __VA_ARGS__
+#endif
+#endif
+
+#ifdef DOXYGEN
+// dummy definitions of config macros for doxygen
+
+/// The major version number.
+/// \ingroup core
+#define WPI_MEMORY_VERSION_MAJOR 1
+
+/// The minor version number.
+/// \ingroup core
+#define WPI_MEMORY_VERSION_MINOR 1
+
+/// The total version number of the form \c Mmm.
+/// \ingroup core
+#define WPI_MEMORY_VERSION                                                                   \
+    (WPI_MEMORY_VERSION_MAJOR * 100 + WPI_MEMORY_VERSION_MINOR)
+
+/// Whether or not the allocation size will be checked,
+/// i.e. the \ref wpi::memory::bad_allocation_size thrown.
+/// \ingroup core
+#define WPI_MEMORY_CHECK_ALLOCATION_SIZE 1
+
+/// Whether or not internal assertions in the library are enabled.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_ASSERT 1
+
+/// Whether or not allocated memory will be filled with special values.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_FILL 1
+
+/// The size of the fence memory, it has no effect if \ref WPI_MEMORY_DEBUG_FILL is \c false.
+/// \note For most allocators, the actual value doesn't matter and they use appropriate defaults to ensure alignment etc.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_FENCE 1
+
+/// Whether or not leak checking is enabled.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_LEAK_CHECK 1
+
+/// Whether or not the deallocation functions will check for pointers that were never allocated by an allocator.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_POINTER_CHECK 1
+
+/// Whether or not the deallocation functions will check for double free errors.
+/// This option makes no sense if \ref WPI_MEMORY_DEBUG_POINTER_CHECK is \c false.
+/// \ingroup core
+#define WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK 1
+
+/// Whether or not everything is in namespace <tt>wpi::memory</tt>.
+/// If \c false, a namespace alias <tt>namespace memory = wpi::memory</tt> is automatically inserted into each header,
+/// allowing to qualify everything with <tt>wpi::</tt>.
+/// \note This option breaks in combination with using <tt>using namespace wpi;</tt>.
+/// \ingroup core
+#define WPI_MEMORY_NAMESPACE_PREFIX 1
+
+/// The mode of the automatic \ref wpi::memory::temporary_stack creation.
+/// Set to `2` to enable automatic lifetime management of the per-thread stack through nifty counter.
+/// Then all memory will be freed upon program termination automatically.
+/// Set to `1` to disable automatic lifetime managment of the per-thread stack,
+/// requires managing it through the \ref wpi::memory::temporary_stack_initializer.
+/// Set to `0` to disable the per-thread stack completely.
+/// \ref get_temporary_stack() will abort the program upon call.
+/// \ingroup allocator
+#define WPI_MEMORY_TEMPORARY_STACK_MODE 2
+#endif
+
+#endif // WPI_MEMORY_CONFIG_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config_impl.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config_impl.hpp
new file mode 100644
index 0000000..1f72375
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/config_impl.hpp
@@ -0,0 +1,34 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+// Copyright (C) 2015-2020 Jonathan Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#pragma once
+
+#include <cstddef>
+
+//=== options ===//
+#define WPI_MEMORY_CHECK_ALLOCATION_SIZE 1
+#define WPI_MEMORY_IMPL_DEFAULT_ALLOCATOR heap_allocator
+#ifdef NDEBUG
+#define WPI_MEMORY_DEBUG_ASSERT 0
+#define WPI_MEMORY_DEBUG_FILL 0
+#define WPI_MEMORY_DEBUG_FENCE 0
+#define WPI_MEMORY_DEBUG_LEAK_CHECK 0
+#define WPI_MEMORY_DEBUG_POINTER_CHECK 0
+#define WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK 0
+#else
+#define WPI_MEMORY_DEBUG_ASSERT 1
+#define WPI_MEMORY_DEBUG_FILL 1
+#define WPI_MEMORY_DEBUG_FENCE 8
+#define WPI_MEMORY_DEBUG_LEAK_CHECK 1
+#define WPI_MEMORY_DEBUG_POINTER_CHECK 1
+#define WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK 1
+#endif
+#define WPI_MEMORY_EXTERN_TEMPLATE 1
+#define WPI_MEMORY_TEMPORARY_STACK_MODE 2
+
+#define WPI_MEMORY_NO_NODE_SIZE 1
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/container.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/container.hpp
new file mode 100644
index 0000000..fd1547f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/container.hpp
@@ -0,0 +1,362 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_CONTAINER_HPP_INCLUDED
+#define WPI_MEMORY_CONTAINER_HPP_INCLUDED
+
+/// \file
+/// Aliasas for STL containers using a certain \concept{concept_rawallocator,RawAllocator}.
+/// \note Only available on a hosted implementation.
+
+#include "config.hpp"
+#if !WPI_HOSTED_IMPLEMENTATION
+#error "This header is only available for a hosted implementation."
+#endif
+
+#include <functional>
+#include <utility>
+
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <queue>
+#include <scoped_allocator>
+#include <set>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "std_allocator.hpp"
+#include "threading.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// \ingroup adapter
+        /// @{
+
+        /// Alias template for an STL container that uses a certain
+        /// \concept{concept_rawallocator,RawAllocator}. It is just a shorthand for a passing in the \c
+        /// RawAllocator wrapped in a \ref wpi::memory::std_allocator.
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(vector, std::vector<T, std_allocator<T, RawAllocator>>);
+
+        /// Same as above but uses \c std::scoped_allocator_adaptor so the allocator is inherited by all
+        /// nested containers.
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            vector_scoped_alloc,
+            std::vector<T, std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(deque, std::deque<T, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            deque_scoped_alloc,
+            std::deque<T, std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(list, std::list<T, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            list_scoped_alloc,
+            std::list<T, std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(forward_list,
+                                 std::forward_list<T, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            forward_list_scoped_alloc,
+            std::forward_list<T, std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(set, std::set<T, std::less<T>, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            set_scoped_alloc,
+            std::set<T, std::less<T>,
+                     std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(multiset,
+                                 std::multiset<T, std::less<T>, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            multiset_scoped_alloc,
+            std::multiset<T, std::less<T>,
+                          std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            map, std::map<Key, Value, std::less<Key>,
+                          std_allocator<std::pair<const Key, Value>, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            map_scoped_alloc,
+            std::map<Key, Value, std::less<Key>,
+                     std::scoped_allocator_adaptor<
+                         std_allocator<std::pair<const Key, Value>, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            multimap, std::multimap<Key, Value, std::less<Key>,
+                                    std_allocator<std::pair<const Key, Value>, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            multimap_scoped_alloc,
+            std::multimap<Key, Value, std::less<Key>,
+                          std::scoped_allocator_adaptor<
+                              std_allocator<std::pair<const Key, Value>, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_set,
+            std::unordered_set<T, std::hash<T>, std::equal_to<T>, std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_set_scoped_alloc,
+            std::unordered_set<T, std::hash<T>, std::equal_to<T>,
+                               std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(unordered_multiset,
+                                 std::unordered_multiset<T, std::hash<T>, std::equal_to<T>,
+                                                         std_allocator<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_multiset_scoped_alloc,
+            std::unordered_multiset<T, std::hash<T>, std::equal_to<T>,
+                                    std::scoped_allocator_adaptor<std_allocator<T, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_map,
+            std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                               std_allocator<std::pair<const Key, Value>, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_map_scoped_alloc,
+            std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                               std::scoped_allocator_adaptor<
+                                   std_allocator<std::pair<const Key, Value>, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_multimap,
+            std::unordered_multimap<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                                    std_allocator<std::pair<const Key, Value>, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename Key, typename Value, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unordered_multimap_scoped_alloc,
+            std::unordered_multimap<Key, Value, std::hash<Key>, std::equal_to<Key>,
+                                    std::scoped_allocator_adaptor<
+                                        std_allocator<std::pair<const Key, Value>, RawAllocator>>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(stack, std::stack<T, deque<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(stack_scoped_alloc,
+                                 std::stack<T, deque_scoped_alloc<T, RawAllocator>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(queue, std::queue<T, deque<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(queue_scoped_alloc,
+                                 std::queue<T, deque_scoped_alloc<T, RawAllocator>>);
+
+        /// \copydoc vector
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(priority_queue, std::priority_queue<T, deque<T, RawAllocator>>);
+        /// \copydoc vector_scoped_alloc
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(priority_queue_scoped_alloc,
+                                 std::priority_queue<T, deque_scoped_alloc<T, RawAllocator>>);
+
+        /// \copydoc vector
+        template <class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            string,
+            std::basic_string<char, std::char_traits<char>, std_allocator<char, RawAllocator>>);
+        /// @}
+
+        /// @{
+        /// Convenience function to create a container adapter using a certain
+        /// \concept{concept_rawallocator,RawAllocator}. \returns An empty adapter with an
+        /// implementation container using a reference to a given allocator. \ingroup adapter
+        template <typename T, class RawAllocator, class Container = deque<T, RawAllocator>>
+        std::stack<T, Container> make_stack(RawAllocator& allocator)
+        {
+            return std::stack<T, Container>{Container(allocator)};
+        }
+
+        /// \copydoc make_stack
+        template <typename T, class RawAllocator, class Container = deque<T, RawAllocator>>
+        std::queue<T, Container> make_queue(RawAllocator& allocator)
+        {
+            return std::queue<T, Container>{Container(allocator)};
+        }
+
+        /// \copydoc make_stack
+        template <typename T, class RawAllocator, class Container = deque<T, RawAllocator>,
+                  class Compare = std::less<T>>
+        std::priority_queue<T, Container, Compare> make_priority_queue(RawAllocator& allocator,
+                                                                       Compare       comp = {})
+        {
+            return std::priority_queue<T, Container, Compare>{detail::move(comp),
+                                                              Container(allocator)};
+        }
+        /// @}
+
+#if !defined(DOXYGEN)
+
+#include "detail/container_node_sizes.hpp"
+
+#if !defined(WPI_MEMORY_NO_NODE_SIZE)
+        /// \exclude
+        namespace detail
+        {
+            template <typename T, class StdAllocator>
+            struct shared_ptr_node_size
+            {
+                static_assert(sizeof(T) != sizeof(T), "unsupported allocator type");
+            };
+
+            template <typename T, class RawAllocator>
+            struct shared_ptr_node_size<T, std_allocator<T, RawAllocator>>
+            : std::conditional<allocator_traits<RawAllocator>::is_stateful::value,
+                               memory::shared_ptr_stateful_node_size<T>,
+                               memory::shared_ptr_stateless_node_size<T>>::type
+            {
+                static_assert(sizeof(std_allocator<T, RawAllocator>) <= sizeof(void*),
+                              "fix node size debugger");
+            };
+
+        } // namespace detail
+
+        template <typename T, class StdAllocator>
+        struct shared_ptr_node_size : detail::shared_ptr_node_size<T, StdAllocator>
+        {
+        };
+#endif
+
+#else
+        /// \ingroup adapter
+        /// @{
+
+        /// Contains the node size of a node based STL container with a specific type.
+        /// These classes are auto-generated and only available if the tools are build and without
+        /// cross-compiling.
+        template <typename T>
+        struct forward_list_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct list_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct set_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct multiset_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct unordered_set_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct unordered_multiset_node_size
+        : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct map_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct multimap_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct unordered_map_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T>
+        struct unordered_multimap_node_size
+        : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+
+        /// \copydoc forward_list_node_size
+        template <typename T, class StdAllocator>
+        struct shared_ptr_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+/// @}
+#endif
+
+#if !defined(WPI_MEMORY_NO_NODE_SIZE)
+        /// The node size required by \ref allocate_shared.
+        /// \note This is similar to \ref shared_ptr_node_size but takes a
+        /// \concept{concept_rawallocator,RawAllocator} instead.
+        template <typename T, class RawAllocator>
+        struct allocate_shared_node_size : shared_ptr_node_size<T, std_allocator<T, RawAllocator>>
+        {
+        };
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_CONTAINER_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/debugging.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/debugging.hpp
new file mode 100644
index 0000000..b04050f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/debugging.hpp
@@ -0,0 +1,114 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DEBUGGING_HPP_INCLUDED
+#define WPI_MEMORY_DEBUGGING_HPP_INCLUDED
+
+/// \file
+/// Debugging facilities.
+
+#include "config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        struct allocator_info;
+
+        /// The magic values that are used for debug filling.
+        /// If \ref WPI_MEMORY_DEBUG_FILL is \c true, memory will be filled to help detect use-after-free or missing initialization errors.
+        /// These are the constants for the different types.
+        /// \ingroup core
+        enum class debug_magic : unsigned char
+        {
+            /// Marks internal memory used by the allocator - "allocated block".
+            internal_memory = 0xAB,
+            /// Marks internal memory currently not used by the allocator - "freed block".
+            internal_freed_memory = 0xFB,
+            /// Marks allocated, but not yet used memory - "clean memory".
+            new_memory = 0xCD,
+            /// Marks freed memory - "dead memory".
+            freed_memory = 0xDD,
+            /// Marks buffer memory used to ensure proper alignment.
+            /// This memory can also serve as \ref debug_magic::fence_memory.
+            alignment_memory = 0xED,
+            /// Marks buffer memory used to protect against overflow - "fence memory".
+            /// The option \ref WPI_MEMORY_DEBUG_FENCE controls the size of a memory fence that will be placed before or after a memory block.
+            /// It helps catching buffer overflows.
+            fence_memory = 0xFD
+        };
+
+        /// The type of the handler called when a memory leak is detected.
+        /// Leak checking can be controlled via the option \ref WPI_MEMORY_DEBUG_LEAK_CHECK
+        /// and only affects calls through the \ref allocator_traits, not direct calls.
+        /// The handler gets the \ref allocator_info and the amount of memory leaked.
+        /// This can also be negative, meaning that more memory has been freed than allocated.
+        /// \requiredbe A leak handler shall log the leak, abort the program, do nothing or anything else that seems appropriate.
+        /// It must not throw any exceptions since it is called in the cleanup process.
+        /// \defaultbe On a hosted implementation it logs the leak to \c stderr and returns, continuing execution.
+        /// On a freestanding implementation it does nothing.
+        /// \ingroup core
+        using leak_handler = void (*)(const allocator_info& info, std::ptrdiff_t amount);
+
+        /// Exchanges the \ref leak_handler.
+        /// \effects Sets \c h as the new \ref leak_handler in an atomic operation.
+        /// A \c nullptr sets the default \ref leak_handler.
+        /// \returns The previous \ref leak_handler. This is never \c nullptr.
+        /// \ingroup core
+        leak_handler set_leak_handler(leak_handler h);
+
+        /// Returns the \ref leak_handler.
+        /// \returns The current \ref leak_handler. This is never \c nullptr.
+        /// \ingroup core
+        leak_handler get_leak_handler();
+
+        /// The type of the handler called when an invalid pointer is passed to a deallocation function.
+        /// Pointer checking can be controlled via the options \ref WPI_MEMORY_DEBUG_POINTER_CHECK and \ref WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK.
+        /// The handler gets the \ref allocator_info and the invalid pointer.
+        /// \requiredbe An invalid pointer handler shall terminate the program.
+        /// It must not throw any exceptions since it might be called in the cleanup process.
+        /// \defaultbe On a hosted implementation it logs the information to \c stderr and calls \c std::abort().
+        /// On a freestanding implementation it only calls \c std::abort().
+        /// \ingroup core
+        using invalid_pointer_handler = void (*)(const allocator_info& info, const void* ptr);
+
+        /// Exchanges the \ref invalid_pointer_handler.
+        /// \effects Sets \c h as the new \ref invalid_pointer_handler in an atomic operation.
+        /// A \c nullptr sets the default \ref invalid_pointer_handler.
+        /// \returns The previous \ref invalid_pointer_handler. This is never \c nullptr.
+        /// \ingroup core
+        invalid_pointer_handler set_invalid_pointer_handler(invalid_pointer_handler h);
+
+        /// Returns the \ref invalid_pointer_handler.
+        /// \returns The current \ref invalid_pointer_handler. This is never \c nullptr.
+        /// \ingroup core
+        invalid_pointer_handler get_invalid_pointer_handler();
+
+        /// The type of the handler called when a buffer under/overflow is detected.
+        /// If \ref WPI_MEMORY_DEBUG_FILL is \c true and \ref WPI_MEMORY_DEBUG_FENCE has a non-zero value
+        /// the allocator classes check if a write into the fence has occured upon deallocation.
+        /// The handler gets the memory block belonging to the corrupted fence, its size and the exact address.
+        /// \requiredbe A buffer overflow handler shall terminate the program.
+        /// It must not throw any exceptions since it me be called in the cleanup process.
+        /// \defaultbe On a hosted implementation it logs the information to \c stderr and calls \c std::abort().
+        /// On a freestanding implementation it only calls \c std::abort().
+        /// \ingroup core
+        using buffer_overflow_handler = void (*)(const void* memory, std::size_t size,
+                                                 const void* write_ptr);
+
+        /// Exchanges the \ref buffer_overflow_handler.
+        /// \effects Sets \c h as the new \ref buffer_overflow_handler in an atomic operation.
+        /// A \c nullptr sets the default \ref buffer_overflow_handler.
+        /// \returns The previous \ref buffer_overflow_handler. This is never \c nullptr.
+        /// \ingroup core
+        buffer_overflow_handler set_buffer_overflow_handler(buffer_overflow_handler h);
+
+        /// Returns the \ref buffer_overflow_handler.
+        /// \returns The current \ref buffer_overflow_handler. This is never \c nullptr.
+        /// \ingroup core
+        buffer_overflow_handler get_buffer_overflow_handler();
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DEBUGGING_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/default_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/default_allocator.hpp
new file mode 100644
index 0000000..107a641
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/default_allocator.hpp
@@ -0,0 +1,37 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DEFAULT_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_DEFAULT_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// The typedef \ref wpi::memory::default_allocator.
+
+#include "config.hpp"
+#include "heap_allocator.hpp"
+#include "new_allocator.hpp"
+#include "static_allocator.hpp"
+#include "virtual_memory.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include "malloc_allocator.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// The default \concept{concept_rawallocator,RawAllocator} that will be used as \concept{concept_blockallocator,BlockAllocator} in memory arenas.
+        /// Arena allocators like \ref memory_stack or \ref memory_pool allocate memory by subdividing a huge block.
+        /// They get a \concept{concept_blockallocator,BlockAllocator} that will be used for their internal allocation,
+        /// this type is the default value.
+        /// \requiredbe Its type can be changed via the CMake option \c WPI_MEMORY_DEFAULT_ALLCOATOR,
+        /// but it must be one of the following: \ref heap_allocator, \ref new_allocator, \ref malloc_allocator, \ref static_allocator, \ref virtual_memory_allocator.
+        /// \defaultbe The default is \ref heap_allocator.
+        /// \ingroup allocator
+        using default_allocator = WPI_IMPL_DEFINED(WPI_MEMORY_IMPL_DEFAULT_ALLOCATOR);
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DEFAULT_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/deleter.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/deleter.hpp
new file mode 100644
index 0000000..01c967c
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/deleter.hpp
@@ -0,0 +1,308 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DELETER_HPP_INCLUDED
+#define WPI_MEMORY_DELETER_HPP_INCLUDED
+
+/// \file
+/// \c Deleter classes using a \concept{concept_rawallocator,RawAllocator}.
+
+#include <type_traits>
+
+#include "allocator_storage.hpp"
+#include "config.hpp"
+#include "threading.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A deleter class that deallocates the memory through a specified \concept{concept_rawallocator,RawAllocator}.
+        ///
+        /// It deallocates memory for a specified type but does not call its destructors.
+        /// \ingroup adapter
+        template <typename Type, class RawAllocator>
+        class allocator_deallocator : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+            static_assert(!std::is_abstract<Type>::value,
+                          "use allocator_polymorphic_deallocator for storing base classes");
+
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = Type;
+
+            /// \effects Creates it without any associated allocator.
+            /// The deallocator must not be used if that is the case.
+            /// \notes This functions is useful if you have want to create an empty smart pointer without giving it an allocator.
+            allocator_deallocator() noexcept = default;
+
+            /// \effects Creates it by passing it an \ref allocator_reference.
+            /// It will store the reference to it and uses the referenced allocator object for the deallocation.
+            allocator_deallocator(allocator_reference<RawAllocator> alloc) noexcept
+            : allocator_reference<RawAllocator>(alloc)
+            {
+            }
+
+            /// \effects Deallocates the memory given to it.
+            /// Calls \c deallocate_node(pointer, sizeof(value_type), alignof(value_type)) on the referenced allocator object.
+            /// \requires The deallocator must not have been created by the default constructor.
+            void operator()(value_type* pointer) noexcept
+            {
+                this->deallocate_node(pointer, sizeof(value_type), alignof(value_type));
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            /// \requires The deallocator must not be created by the default constructor.
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+        };
+
+        /// Specialization of \ref allocator_deallocator for array types.
+        /// Otherwise the same behavior.
+        /// \ingroup adapter
+        template <typename Type, class RawAllocator>
+        class allocator_deallocator<Type[], RawAllocator>
+        : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+            static_assert(!std::is_abstract<Type>::value, "must not create polymorphic arrays");
+
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = Type;
+
+            /// \effects Creates it without any associated allocator.
+            /// The deallocator must not be used if that is the case.
+            /// \notes This functions is useful if you have want to create an empty smart pointer without giving it an allocator.
+            allocator_deallocator() noexcept : size_(0u) {}
+
+            /// \effects Creates it by passing it an \ref allocator_reference and the size of the array that will be deallocated.
+            /// It will store the reference to the allocator and uses the referenced allocator object for the deallocation.
+            allocator_deallocator(allocator_reference<RawAllocator> alloc,
+                                  std::size_t                       size) noexcept
+            : allocator_reference<RawAllocator>(alloc), size_(size)
+            {
+            }
+
+            /// \effects Deallocates the memory given to it.
+            /// Calls \c deallocate_array(pointer, size, sizeof(value_type), alignof(value_type))
+            /// on the referenced allocator object with the size given in the constructor.
+            /// \requires The deallocator must not have been created by the default constructor.
+            void operator()(value_type* pointer) noexcept
+            {
+                this->deallocate_array(pointer, size_, sizeof(value_type), alignof(value_type));
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            /// \requires The deallocator must not have been created by the default constructor.
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+
+            /// \returns The size of the array that will be deallocated.
+            /// This is the same value as passed in the constructor, or `0` if it was created by the default constructor.
+            std::size_t array_size() const noexcept
+            {
+                return size_;
+            }
+
+        private:
+            std::size_t size_;
+        };
+
+        /// A deleter class that deallocates the memory of a derived type through a specified \concept{concept_rawallocator,RawAllocator}.
+        ///
+        /// It can only be created from a \ref allocator_deallocator and thus must only be used for smart pointers initialized by derived-to-base conversion of the pointer.
+        /// \ingroup adapter
+        template <typename BaseType, class RawAllocator>
+        class allocator_polymorphic_deallocator : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = BaseType;
+
+            /// \effects Creates it from a deallocator for a derived type.
+            /// It will deallocate the memory as if done by the derived type.
+            template <typename T, WPI_REQUIRES((std::is_base_of<BaseType, T>::value))>
+            allocator_polymorphic_deallocator(allocator_deallocator<T, RawAllocator> dealloc)
+            : allocator_reference<RawAllocator>(dealloc.get_allocator()),
+              derived_size_(sizeof(T)),
+              derived_alignment_(alignof(T))
+            {
+            }
+
+            /// \effects Deallocates the memory given to it.
+            /// Calls \c deallocate_node(pointer, size, alignment) on the referenced allocator object,
+            /// where \c size and \c alignment are the values of the type it was created with.
+            void operator()(value_type* pointer) noexcept
+            {
+                this->deallocate_node(pointer, derived_size_, derived_alignment_);
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+
+        private:
+            std::size_t derived_size_, derived_alignment_;
+        };
+
+        /// Similar to \ref allocator_deallocator but calls the destructors of the object.
+        /// Otherwise behaves the same.
+        /// \ingroup adapter
+        template <typename Type, class RawAllocator>
+        class allocator_deleter : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+            static_assert(!std::is_abstract<Type>::value,
+                          "use allocator_polymorphic_deleter for storing base classes");
+
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = Type;
+
+            /// \effects Creates it without any associated allocator.
+            /// The deleter must not be used if that is the case.
+            /// \notes This functions is useful if you have want to create an empty smart pointer without giving it an allocator.
+            allocator_deleter() noexcept = default;
+
+            /// \effects Creates it by passing it an \ref allocator_reference.
+            /// It will store the reference to it and uses the referenced allocator object for the deallocation.
+            allocator_deleter(allocator_reference<RawAllocator> alloc) noexcept
+            : allocator_reference<RawAllocator>(alloc)
+            {
+            }
+
+            /// \effects Calls the destructor and deallocates the memory given to it.
+            /// Calls \c deallocate_node(pointer, sizeof(value_type), alignof(value_type))
+            /// on the referenced allocator object for the deallocation.
+            /// \requires The deleter must not have been created by the default constructor.
+            void operator()(value_type* pointer) noexcept
+            {
+                pointer->~value_type();
+                this->deallocate_node(pointer, sizeof(value_type), alignof(value_type));
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+        };
+
+        /// Specialization of \ref allocator_deleter for array types.
+        /// Otherwise the same behavior.
+        /// \ingroup adapter
+        template <typename Type, class RawAllocator>
+        class allocator_deleter<Type[], RawAllocator>
+        : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+            static_assert(!std::is_abstract<Type>::value, "must not create polymorphic arrays");
+
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = Type;
+
+            /// \effects Creates it without any associated allocator.
+            /// The deleter must not be used if that is the case.
+            /// \notes This functions is useful if you have want to create an empty smart pointer without giving it an allocator.
+            allocator_deleter() noexcept : size_(0u) {}
+
+            /// \effects Creates it by passing it an \ref allocator_reference and the size of the array that will be deallocated.
+            /// It will store the reference to the allocator and uses the referenced allocator object for the deallocation.
+            allocator_deleter(allocator_reference<RawAllocator> alloc, std::size_t size) noexcept
+            : allocator_reference<RawAllocator>(alloc), size_(size)
+            {
+            }
+
+            /// \effects Calls the destructors and deallocates the memory given to it.
+            /// Calls \c deallocate_array(pointer, size, sizeof(value_type), alignof(value_type))
+            /// on the referenced allocator object with the size given in the constructor for the deallocation.
+            /// \requires The deleter must not have been created by the default constructor.
+            void operator()(value_type* pointer) noexcept
+            {
+                for (auto cur = pointer; cur != pointer + size_; ++cur)
+                    cur->~value_type();
+                this->deallocate_array(pointer, size_, sizeof(value_type), alignof(value_type));
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            /// \requires The deleter must not be created by the default constructor.
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+
+            /// \returns The size of the array that will be deallocated.
+            /// This is the same value as passed in the constructor, or `0` if it was created by the default constructor.
+            std::size_t array_size() const noexcept
+            {
+                return size_;
+            }
+
+        private:
+            std::size_t size_;
+        };
+
+        /// Similar to \ref allocator_polymorphic_deallocator but calls the destructors of the object.
+        /// Otherwise behaves the same.
+        /// \note It has a relatively high space overhead, so only use it if you have to.
+        /// \ingroup adapter
+        template <typename BaseType, class RawAllocator>
+        class allocator_polymorphic_deleter : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+        public:
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+            using value_type     = BaseType;
+
+            /// \effects Creates it from a deleter for a derived type.
+            /// It will deallocate the memory as if done by the derived type.
+            template <typename T, WPI_REQUIRES((std::is_base_of<BaseType, T>::value))>
+            allocator_polymorphic_deleter(allocator_deleter<T, RawAllocator> deleter)
+            : allocator_reference<RawAllocator>(deleter.get_allocator()),
+              derived_size_(sizeof(T)),
+              derived_alignment_(alignof(T))
+            {
+                WPI_MEMORY_ASSERT(std::size_t(derived_size_) == sizeof(T)
+                                        && std::size_t(derived_alignment_) == alignof(T));
+            }
+
+            /// \effects Deallocates the memory given to it.
+            /// Calls \c deallocate_node(pointer, size, alignment) on the referenced allocator object,
+            /// where \c size and \c alignment are the values of the type it was created with.
+            void operator()(value_type* pointer) noexcept
+            {
+                pointer->~value_type();
+                this->deallocate_node(pointer, derived_size_, derived_alignment_);
+            }
+
+            /// \returns The reference to the allocator.
+            /// It has the same type as the call to \ref allocator_reference::get_allocator().
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+
+        private:
+            unsigned short derived_size_,
+                derived_alignment_; // use unsigned short here to save space
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_DELETER_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/align.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/align.hpp
new file mode 100644
index 0000000..99d6bcc
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/align.hpp
@@ -0,0 +1,52 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_ALIGN_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_ALIGN_HPP_INCLUDED
+
+#include <cstdint>
+
+#include "../config.hpp"
+#include "assert.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // whether or not an alignment is valid, i.e. a power of two not zero
+            constexpr bool is_valid_alignment(std::size_t alignment) noexcept
+            {
+                return alignment && (alignment & (alignment - 1)) == 0u;
+            }
+
+            // returns the offset needed to align ptr for given alignment
+            // alignment must be valid
+            inline std::size_t align_offset(std::uintptr_t address, std::size_t alignment) noexcept
+            {
+                WPI_MEMORY_ASSERT(is_valid_alignment(alignment));
+                auto misaligned = address & (alignment - 1);
+                return misaligned != 0 ? (alignment - misaligned) : 0;
+            }
+            inline std::size_t align_offset(void* ptr, std::size_t alignment) noexcept
+            {
+                return align_offset(reinterpret_cast<std::uintptr_t>(ptr), alignment);
+            }
+
+            // whether or not the pointer is aligned for given alignment
+            // alignment must be valid
+            bool is_aligned(void* ptr, std::size_t alignment) noexcept;
+
+            // maximum alignment value
+            constexpr std::size_t max_alignment = alignof(std::max_align_t);
+            static_assert(is_valid_alignment(max_alignment), "ehm..?");
+
+            // returns the minimum alignment required for a node of given size
+            std::size_t alignment_for(std::size_t size) noexcept;
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_ALIGN_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/assert.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/assert.hpp
new file mode 100644
index 0000000..b8a7372
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/assert.hpp
@@ -0,0 +1,57 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_ASSERT_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_ASSERT_HPP_INCLUDED
+
+#include <cstdlib>
+
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // handles a failed assertion
+            void handle_failed_assert(const char* msg, const char* file, int line,
+                                      const char* fnc) noexcept;
+
+            void handle_warning(const char* msg, const char* file, int line,
+                                const char* fnc) noexcept;
+
+// note: debug assertion macros don't use fully qualified name
+// because they should only be used in this library, where the whole namespace is available
+// can be override via command line definitions
+#if WPI_MEMORY_DEBUG_ASSERT && !defined(WPI_MEMORY_ASSERT)
+#define WPI_MEMORY_ASSERT(Expr)                                                              \
+    static_cast<void>((Expr)                                                                       \
+                      || (detail::handle_failed_assert("Assertion \"" #Expr "\" failed", __FILE__, \
+                                                       __LINE__, __func__),                        \
+                          true))
+
+#define WPI_MEMORY_ASSERT_MSG(Expr, Msg)                                                     \
+    static_cast<void>((Expr)                                                                       \
+                      || (detail::handle_failed_assert("Assertion \"" #Expr "\" failed: " Msg,     \
+                                                       __FILE__, __LINE__, __func__),              \
+                          true))
+
+#define WPI_MEMORY_UNREACHABLE(Msg)                                                          \
+    detail::handle_failed_assert("Unreachable code reached: " Msg, __FILE__, __LINE__, __func__)
+
+#define WPI_MEMORY_WARNING(Msg) detail::handle_warning(Msg, __FILE__, __LINE__, __func__)
+
+#elif !defined(WPI_MEMORY_ASSERT)
+#define WPI_MEMORY_ASSERT(Expr)
+#define WPI_MEMORY_ASSERT_MSG(Expr, Msg)
+#define WPI_MEMORY_UNREACHABLE(Msg) std::abort()
+#define WPI_MEMORY_WARNING(Msg)
+#endif
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_ASSERT_HPP_INCLUDED
+
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/container_node_sizes.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/container_node_sizes.hpp
new file mode 100644
index 0000000..37949ca
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/container_node_sizes.hpp
@@ -0,0 +1,10 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_CONTAINER_NODE_SIZES_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_CONTAINER_NODE_SIZES_HPP_INCLUDED
+
+#include "container_node_sizes_impl.hpp"
+
+#endif //WPI_MEMORY_DETAIL_CONTAINER_NODE_SIZES_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/debug_helpers.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/debug_helpers.hpp
new file mode 100644
index 0000000..3ef2eed
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/debug_helpers.hpp
@@ -0,0 +1,235 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DEBUG_HELPERS_HPP_INCLUDED
+#define WPI_MEMORY_DEBUG_HELPERS_HPP_INCLUDED
+
+#include <atomic>
+#include <type_traits>
+
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        enum class debug_magic : unsigned char;
+        struct allocator_info;
+
+        namespace detail
+        {
+            using debug_fill_enabled = std::integral_constant<bool, WPI_MEMORY_DEBUG_FILL>;
+            constexpr std::size_t debug_fence_size =
+                WPI_MEMORY_DEBUG_FILL ? WPI_MEMORY_DEBUG_FENCE : 0u;
+
+#if WPI_MEMORY_DEBUG_FILL
+            // fills size bytes of memory with debug_magic
+            void debug_fill(void* memory, std::size_t size, debug_magic m) noexcept;
+
+            // returns nullptr if memory is filled with debug_magic
+            // else returns pointer to mismatched byte
+            void* debug_is_filled(void* memory, std::size_t size, debug_magic m) noexcept;
+
+            // fills fence, new and fence
+            // returns after fence
+            void* debug_fill_new(void* memory, std::size_t node_size,
+                                 std::size_t fence_size = debug_fence_size) noexcept;
+
+            // fills free memory and returns memory starting at fence
+            void* debug_fill_free(void* memory, std::size_t node_size,
+                                  std::size_t fence_size = debug_fence_size) noexcept;
+
+            // fills internal memory
+            void debug_fill_internal(void* memory, std::size_t size, bool free) noexcept;
+#else
+            inline void debug_fill(void*, std::size_t, debug_magic) noexcept {}
+
+            inline void* debug_is_filled(void*, std::size_t, debug_magic) noexcept
+            {
+                return nullptr;
+            }
+
+            inline void* debug_fill_new(void* memory, std::size_t, std::size_t) noexcept
+            {
+                return memory;
+            }
+
+            inline void* debug_fill_free(void* memory, std::size_t, std::size_t) noexcept
+            {
+                return static_cast<char*>(memory);
+            }
+
+            inline void debug_fill_internal(void*, std::size_t, bool) noexcept {}
+#endif
+
+            void debug_handle_invalid_ptr(const allocator_info& info, void* ptr);
+
+            // validates given ptr by evaluating the Functor
+            // if the Functor returns false, calls the debug_leak_checker
+            // note: ptr is just used as the information passed to the invalid ptr handler
+            template <class Functor>
+            void debug_check_pointer(Functor condition, const allocator_info& info, void* ptr)
+            {
+#if WPI_MEMORY_DEBUG_POINTER_CHECK
+                if (!condition())
+                    debug_handle_invalid_ptr(info, ptr);
+#else
+                (void)ptr;
+                (void)condition;
+                (void)info;
+#endif
+            }
+
+            // validates ptr by using a more expensive double-dealloc check
+            template <class Functor>
+            void debug_check_double_dealloc(Functor condition, const allocator_info& info,
+                                            void* ptr)
+            {
+#if WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK
+                debug_check_pointer(condition, info, ptr);
+#else
+                (void)condition;
+                (void)info;
+                (void)ptr;
+#endif
+            }
+
+            void debug_handle_memory_leak(const allocator_info& info, std::ptrdiff_t amount);
+
+            // does no leak checking, null overhead
+            template <class Handler>
+            class no_leak_checker
+            {
+            public:
+                no_leak_checker() noexcept {}
+                no_leak_checker(no_leak_checker&&) noexcept {}
+                ~no_leak_checker() noexcept {}
+
+                no_leak_checker& operator=(no_leak_checker&&) noexcept
+                {
+                    return *this;
+                }
+
+                void on_allocate(std::size_t) noexcept {}
+                void on_deallocate(std::size_t) noexcept {}
+            };
+
+            // does leak checking per-object
+            // leak is detected upon destructor
+            template <class Handler>
+            class object_leak_checker : Handler
+            {
+            public:
+                object_leak_checker() noexcept : allocated_(0) {}
+
+                object_leak_checker(object_leak_checker&& other) noexcept
+                : allocated_(other.allocated_)
+                {
+                    other.allocated_ = 0;
+                }
+
+                ~object_leak_checker() noexcept
+                {
+                    if (allocated_ != 0)
+                        this->operator()(allocated_);
+                }
+
+                object_leak_checker& operator=(object_leak_checker&& other) noexcept
+                {
+                    allocated_       = other.allocated_;
+                    other.allocated_ = 0;
+                    return *this;
+                }
+
+                void on_allocate(std::size_t size) noexcept
+                {
+                    allocated_ += std::ptrdiff_t(size);
+                }
+
+                void on_deallocate(std::size_t size) noexcept
+                {
+                    allocated_ -= std::ptrdiff_t(size);
+                }
+
+            private:
+                std::ptrdiff_t allocated_;
+            };
+
+            // does leak checking on a global basis
+            // call macro WPI_MEMORY_GLOBAL_LEAK_CHECKER(handler, var_name) in the header
+            // when last counter gets destroyed, leak is detected
+            template <class Handler>
+            class global_leak_checker_impl
+            {
+            public:
+                struct counter : Handler
+                {
+                    counter()
+                    {
+                        ++no_counter_objects_;
+                    }
+
+                    ~counter()
+                    {
+                        --no_counter_objects_;
+                        if (no_counter_objects_ == 0u && allocated_ != 0u)
+                            this->operator()(allocated_);
+                    }
+                };
+
+                global_leak_checker_impl() noexcept {}
+                global_leak_checker_impl(global_leak_checker_impl&&) noexcept {}
+                ~global_leak_checker_impl() noexcept {}
+
+                global_leak_checker_impl& operator=(global_leak_checker_impl&&) noexcept
+                {
+                    return *this;
+                }
+
+                void on_allocate(std::size_t size) noexcept
+                {
+                    allocated_ += std::ptrdiff_t(size);
+                }
+
+                void on_deallocate(std::size_t size) noexcept
+                {
+                    allocated_ -= std::ptrdiff_t(size);
+                }
+
+            private:
+                static std::atomic<std::size_t>    no_counter_objects_;
+                static std::atomic<std::ptrdiff_t> allocated_;
+            };
+
+            template <class Handler>
+            std::atomic<std::size_t> global_leak_checker_impl<Handler>::no_counter_objects_(0u);
+
+            template <class Handler>
+            std::atomic<std::ptrdiff_t> global_leak_checker_impl<Handler>::allocated_(0);
+
+#if WPI_MEMORY_DEBUG_LEAK_CHECK
+            template <class Handler>
+            using global_leak_checker = global_leak_checker_impl<Handler>;
+
+#define WPI_MEMORY_GLOBAL_LEAK_CHECKER(handler, var_name)                                    \
+    static wpi::memory::detail::global_leak_checker<handler>::counter var_name;
+#else
+            template <class Handler>
+            using global_leak_checker = no_leak_checker<int>; // only one instantiation
+
+#define WPI_MEMORY_GLOBAL_LEAK_CHECKER(handler, var_name)
+#endif
+
+#if WPI_MEMORY_DEBUG_LEAK_CHECK
+            template <class Handler>
+            using default_leak_checker = object_leak_checker<Handler>;
+#else
+            template <class Handler>
+            using default_leak_checker = no_leak_checker<Handler>;
+#endif
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DEBUG_HELPERS_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ebo_storage.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ebo_storage.hpp
new file mode 100644
index 0000000..de53f7f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ebo_storage.hpp
@@ -0,0 +1,42 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_EBO_STORAGE_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_EBO_STORAGE_HPP_INCLUDED
+
+#include "utility.hpp"
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <int Tag, typename T>
+            class ebo_storage : T
+            {
+            protected:
+                ebo_storage(const T& t) : T(t) {}
+
+                ebo_storage(T&& t) noexcept(std::is_nothrow_move_constructible<T>::value)
+                : T(detail::move(t))
+                {
+                }
+
+                T& get() noexcept
+                {
+                    return *this;
+                }
+
+                const T& get() const noexcept
+                {
+                    return *this;
+                }
+            };
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_EBO_STORAGE_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list.hpp
new file mode 100644
index 0000000..612706d
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list.hpp
@@ -0,0 +1,228 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAILL_FREE_LIST_HPP_INCLUDED
+#define WPI_MEMORY_DETAILL_FREE_LIST_HPP_INCLUDED
+
+#include <cstddef>
+#include <cstdint>
+
+#include "align.hpp"
+#include "utility.hpp"
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // stores free blocks for a memory pool
+            // memory blocks are fragmented and stored in a list
+            // debug: fills memory and uses a bigger node_size for fence memory
+            class free_memory_list
+            {
+            public:
+                // minimum element size
+                static constexpr auto min_element_size = sizeof(char*);
+                // alignment
+                static constexpr auto min_element_alignment = alignof(char*);
+
+                // minimal size of the block that needs to be inserted
+                static constexpr std::size_t min_block_size(std::size_t node_size,
+                                                            std::size_t number_of_nodes)
+                {
+                    return (node_size < min_element_size ? min_element_size : node_size)
+                           * number_of_nodes;
+                }
+
+                //=== constructor ===//
+                free_memory_list(std::size_t node_size) noexcept;
+
+                // calls other constructor plus insert
+                free_memory_list(std::size_t node_size, void* mem, std::size_t size) noexcept;
+
+                free_memory_list(free_memory_list&& other) noexcept;
+                ~free_memory_list() noexcept = default;
+
+                free_memory_list& operator=(free_memory_list&& other) noexcept;
+
+                friend void swap(free_memory_list& a, free_memory_list& b) noexcept;
+
+                //=== insert/allocation/deallocation ===//
+                // inserts a new memory block, by splitting it up and setting the links
+                // does not own memory!
+                // mem must be aligned for alignment()
+                // pre: size != 0
+                void insert(void* mem, std::size_t size) noexcept;
+
+                // returns the usable size
+                // i.e. how many memory will be actually inserted and usable on a call to insert()
+                std::size_t usable_size(std::size_t size) const noexcept
+                {
+                    // Round down to next multiple of node size.
+                    return (size / node_size_) * node_size_;
+                }
+
+                // returns a single block from the list
+                // pre: !empty()
+                void* allocate() noexcept;
+
+                // returns a memory block big enough for n bytes
+                // might fail even if capacity is sufficient
+                void* allocate(std::size_t n) noexcept;
+
+                // deallocates a single block
+                void deallocate(void* ptr) noexcept;
+
+                // deallocates multiple blocks with n bytes total
+                void deallocate(void* ptr, std::size_t n) noexcept;
+
+                //=== getter ===//
+                std::size_t node_size() const noexcept
+                {
+                    return node_size_;
+                }
+
+                // alignment of all nodes
+                std::size_t alignment() const noexcept;
+
+                // number of nodes remaining
+                std::size_t capacity() const noexcept
+                {
+                    return capacity_;
+                }
+
+                bool empty() const noexcept
+                {
+                    return first_ == nullptr;
+                }
+
+            private:
+                void insert_impl(void* mem, std::size_t size) noexcept;
+
+                char*       first_;
+                std::size_t node_size_, capacity_;
+            };
+
+            void swap(free_memory_list& a, free_memory_list& b) noexcept;
+
+            // same as above but keeps the nodes ordered
+            // this allows array allocations, that is, consecutive nodes
+            // debug: fills memory and uses a bigger node_size for fence memory
+            class ordered_free_memory_list
+            {
+            public:
+                // minimum element size
+                static constexpr auto min_element_size = sizeof(char*);
+                // alignment
+                static constexpr auto min_element_alignment = alignof(char*);
+
+                // minimal size of the block that needs to be inserted
+                static constexpr std::size_t min_block_size(std::size_t node_size,
+                                                            std::size_t number_of_nodes)
+                {
+                    return (node_size < min_element_size ? min_element_size : node_size)
+                           * number_of_nodes;
+                }
+
+                //=== constructor ===//
+                ordered_free_memory_list(std::size_t node_size) noexcept;
+
+                ordered_free_memory_list(std::size_t node_size, void* mem,
+                                         std::size_t size) noexcept
+                : ordered_free_memory_list(node_size)
+                {
+                    insert(mem, size);
+                }
+
+                ordered_free_memory_list(ordered_free_memory_list&& other) noexcept;
+
+                ~ordered_free_memory_list() noexcept = default;
+
+                ordered_free_memory_list& operator=(ordered_free_memory_list&& other) noexcept
+                {
+                    ordered_free_memory_list tmp(detail::move(other));
+                    swap(*this, tmp);
+                    return *this;
+                }
+
+                friend void swap(ordered_free_memory_list& a, ordered_free_memory_list& b) noexcept;
+
+                //=== insert/allocation/deallocation ===//
+                // inserts a new memory block, by splitting it up and setting the links
+                // does not own memory!
+                // mem must be aligned for alignment()
+                // pre: size != 0
+                void insert(void* mem, std::size_t size) noexcept;
+
+                // returns the usable size
+                // i.e. how many memory will be actually inserted and usable on a call to insert()
+                std::size_t usable_size(std::size_t size) const noexcept
+                {
+                    // Round down to next multiple of node size.
+                    return (size / node_size_) * node_size_;
+                }
+
+                // returns a single block from the list
+                // pre: !empty()
+                void* allocate() noexcept;
+
+                // returns a memory block big enough for n bytes (!, not nodes)
+                // might fail even if capacity is sufficient
+                void* allocate(std::size_t n) noexcept;
+
+                // deallocates a single block
+                void deallocate(void* ptr) noexcept;
+
+                // deallocates multiple blocks with n bytes total
+                void deallocate(void* ptr, std::size_t n) noexcept;
+
+                //=== getter ===//
+                std::size_t node_size() const noexcept
+                {
+                    return node_size_;
+                }
+
+                // alignment of all nodes
+                std::size_t alignment() const noexcept;
+
+                // number of nodes remaining
+                std::size_t capacity() const noexcept
+                {
+                    return capacity_;
+                }
+
+                bool empty() const noexcept
+                {
+                    return capacity_ == 0u;
+                }
+
+            private:
+                // returns previous pointer
+                char* insert_impl(void* mem, std::size_t size) noexcept;
+
+                char* begin_node() noexcept;
+                char* end_node() noexcept;
+
+                std::uintptr_t begin_proxy_, end_proxy_;
+                std::size_t    node_size_, capacity_;
+                char *         last_dealloc_, *last_dealloc_prev_;
+            };
+
+            void swap(ordered_free_memory_list& a, ordered_free_memory_list& b) noexcept;
+
+#if WPI_MEMORY_DEBUG_DOUBLE_DEALLOC_CHECK
+            // use ordered version to allow pointer check
+            using node_free_memory_list  = ordered_free_memory_list;
+            using array_free_memory_list = ordered_free_memory_list;
+#else
+            using node_free_memory_list  = free_memory_list;
+            using array_free_memory_list = ordered_free_memory_list;
+#endif
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAILL_FREE_LIST_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list_array.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list_array.hpp
new file mode 100644
index 0000000..ec57e1e
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/free_list_array.hpp
@@ -0,0 +1,126 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_FREE_LIST_ARRAY_HPP
+#define WPI_MEMORY_DETAIL_FREE_LIST_ARRAY_HPP
+
+#include "align.hpp"
+#include "assert.hpp"
+#include "memory_stack.hpp"
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // an array of free_memory_list types
+            // indexed via size, AccessPolicy does necessary conversions
+            // requires trivial destructible FreeList type
+            template <class FreeList, class AccessPolicy>
+            class free_list_array
+            {
+                // not supported on GCC 4.7
+                //static_assert(std::is_trivially_destructible<FreeList>::value,
+                //            "free list must be trivially destructible");
+            public:
+                // creates sufficient elements to support up to given maximum node size
+                // all lists are initially empty
+                // actual number is calculated via policy
+                // memory is taken from fixed_memory_stack, it must be sufficient
+                free_list_array(fixed_memory_stack& stack, const char* end,
+                                std::size_t max_node_size) noexcept
+                : no_elements_(AccessPolicy::index_from_size(max_node_size) - min_size_index + 1)
+                {
+                    array_ = static_cast<FreeList*>(
+                        stack.allocate(end, no_elements_ * sizeof(FreeList), alignof(FreeList)));
+                    WPI_MEMORY_ASSERT_MSG(array_, "insufficient memory for free lists");
+                    for (std::size_t i = 0u; i != no_elements_; ++i)
+                    {
+                        auto node_size = AccessPolicy::size_from_index(i + min_size_index);
+                        ::new (static_cast<void*>(array_ + i)) FreeList(node_size);
+                    }
+                }
+
+                // move constructor, does not actually move the elements, just the pointer
+                free_list_array(free_list_array&& other) noexcept
+                : array_(other.array_), no_elements_(other.no_elements_)
+                {
+                    other.array_       = nullptr;
+                    other.no_elements_ = 0u;
+                }
+
+                // destructor, does nothing, list must be trivially destructible!
+                ~free_list_array() noexcept = default;
+
+                free_list_array& operator=(free_list_array&& other) noexcept
+                {
+                    array_       = other.array_;
+                    no_elements_ = other.no_elements_;
+
+                    other.array_       = nullptr;
+                    other.no_elements_ = 0u;
+                    return *this;
+                }
+
+                // access free list for given size
+                FreeList& get(std::size_t node_size) const noexcept
+                {
+                    auto i = AccessPolicy::index_from_size(node_size);
+                    if (i < min_size_index)
+                        i = min_size_index;
+                    return array_[i - min_size_index];
+                }
+
+                // number of free lists
+                std::size_t size() const noexcept
+                {
+                    return no_elements_;
+                }
+
+                // maximum supported node size
+                std::size_t max_node_size() const noexcept
+                {
+                    return AccessPolicy::size_from_index(no_elements_ + min_size_index - 1);
+                }
+
+            private:
+                static const std::size_t min_size_index;
+
+                FreeList*   array_;
+                std::size_t no_elements_;
+            };
+
+            template <class FL, class AP>
+            const std::size_t free_list_array<FL, AP>::min_size_index =
+                AP::index_from_size(FL::min_element_size);
+
+            // AccessPolicy that maps size to indices 1:1
+            // creates a free list for each size!
+            struct identity_access_policy
+            {
+                static std::size_t index_from_size(std::size_t size) noexcept
+                {
+                    return size;
+                }
+
+                static std::size_t size_from_index(std::size_t index) noexcept
+                {
+                    return index;
+                }
+            };
+
+            // AccessPolicy that maps sizes to the integral log2
+            // this creates more nodes and never wastes more than half the size
+            struct log2_access_policy
+            {
+                static std::size_t index_from_size(std::size_t size) noexcept;
+                static std::size_t size_from_index(std::size_t index) noexcept;
+            };
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_DETAIL_FREE_LIST_ARRAY_HPP
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ilog2.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ilog2.hpp
new file mode 100644
index 0000000..5cf125a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/ilog2.hpp
@@ -0,0 +1,69 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_ILOG2_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_ILOG2_HPP_INCLUDED
+
+#include <climits>
+#include <cstdint>
+
+#include "../config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // undefined for 0
+            template <typename UInt>
+            constexpr bool is_power_of_two(UInt x)
+            {
+                return (x & (x - 1)) == 0;
+            }
+
+            inline std::size_t ilog2_base(std::uint64_t x)
+            {
+#if defined(__GNUC__)
+                unsigned long long value = x;
+                return sizeof(value) * CHAR_BIT - static_cast<unsigned>(__builtin_clzll(value));
+#else
+                // Adapted from https://stackoverflow.com/a/40943402
+                std::size_t clz = 64;
+                std::size_t c   = 32;
+                do
+                {
+                    auto tmp = x >> c;
+                    if (tmp != 0)
+                    {
+                        clz -= c;
+                        x = tmp;
+                    }
+                    c = c >> 1;
+                } while (c != 0);
+                clz -= x ? 1 : 0;
+
+                return 64 - clz;
+#endif
+            }
+
+            // ilog2() implementation, cuts part after the comma
+            // e.g. 1 -> 0, 2 -> 1, 3 -> 1, 4 -> 2, 5 -> 2
+            inline std::size_t ilog2(std::uint64_t x)
+            {
+                return ilog2_base(x) - 1;
+            }
+
+            // ceiling ilog2() implementation, adds one if part after comma
+            // e.g. 1 -> 0, 2 -> 1, 3 -> 2, 4 -> 2, 5 -> 3
+            inline std::size_t ilog2_ceil(std::uint64_t x)
+            {
+                // only subtract one if power of two
+                return ilog2_base(x) - std::size_t(is_power_of_two(x));
+            }
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/lowlevel_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/lowlevel_allocator.hpp
new file mode 100644
index 0000000..2ac45a5
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/lowlevel_allocator.hpp
@@ -0,0 +1,86 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_LOWLEVEL_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_LOWLEVEL_ALLOCATOR_HPP_INCLUDED
+
+#include <type_traits>
+
+#include "../config.hpp"
+#include "../error.hpp"
+#include "align.hpp"
+#include "debug_helpers.hpp"
+#include "assert.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <class Functor>
+            struct lowlevel_allocator_leak_handler
+            {
+                void operator()(std::ptrdiff_t amount)
+                {
+                    debug_handle_memory_leak(Functor::info(), amount);
+                }
+            };
+
+            // Functor controls low-level allocation:
+            // static allocator_info info()
+            // static void* allocate(std::size_t size, std::size_t alignment);
+            // static void deallocate(void *memory, std::size_t size, std::size_t alignment);
+            // static std::size_t max_node_size();
+            template <class Functor>
+            class lowlevel_allocator : global_leak_checker<lowlevel_allocator_leak_handler<Functor>>
+            {
+            public:
+                using is_stateful = std::false_type;
+
+                lowlevel_allocator() noexcept {}
+                lowlevel_allocator(lowlevel_allocator&&) noexcept {}
+                ~lowlevel_allocator() noexcept {}
+
+                lowlevel_allocator& operator=(lowlevel_allocator&&) noexcept
+                {
+                    return *this;
+                }
+
+                void* allocate_node(std::size_t size, std::size_t alignment)
+                {
+                    auto actual_size = size + (debug_fence_size ? 2 * max_alignment : 0u);
+
+                    auto memory = Functor::allocate(actual_size, alignment);
+                    if (!memory)
+                        WPI_THROW(out_of_memory(Functor::info(), actual_size));
+
+                    this->on_allocate(actual_size);
+
+                    return debug_fill_new(memory, size, max_alignment);
+                }
+
+                void deallocate_node(void* node, std::size_t size, std::size_t alignment) noexcept
+                {
+                    auto actual_size = size + (debug_fence_size ? 2 * max_alignment : 0u);
+
+                    auto memory = debug_fill_free(node, size, max_alignment);
+                    Functor::deallocate(memory, actual_size, alignment);
+
+                    this->on_deallocate(actual_size);
+                }
+
+                std::size_t max_node_size() const noexcept
+                {
+                    return Functor::max_node_size();
+                }
+            };
+
+#define WPI_MEMORY_LL_ALLOCATOR_LEAK_CHECKER(functor, var_name)                              \
+    WPI_MEMORY_GLOBAL_LEAK_CHECKER(lowlevel_allocator_leak_handler<functor>, var_name)
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_LOWLEVEL_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/memory_stack.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/memory_stack.hpp
new file mode 100644
index 0000000..e49d480
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/memory_stack.hpp
@@ -0,0 +1,120 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_MEMORY_STACK_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_MEMORY_STACK_HPP_INCLUDED
+
+#include <cstddef>
+
+#include "../config.hpp"
+#include "align.hpp"
+#include "debug_helpers.hpp"
+#include "../debugging.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // simple memory stack implementation that does not support growing
+            class fixed_memory_stack
+            {
+            public:
+                fixed_memory_stack() noexcept : fixed_memory_stack(nullptr) {}
+
+                // gives it the current pointer, the end pointer must be maintained seperataly
+                explicit fixed_memory_stack(void* memory) noexcept
+                : cur_(static_cast<char*>(memory))
+                {
+                }
+
+                fixed_memory_stack(fixed_memory_stack&& other) noexcept : cur_(other.cur_)
+                {
+                    other.cur_ = nullptr;
+                }
+
+                ~fixed_memory_stack() noexcept = default;
+
+                fixed_memory_stack& operator=(fixed_memory_stack&& other) noexcept
+                {
+                    cur_       = other.cur_;
+                    other.cur_ = nullptr;
+                    return *this;
+                }
+
+                // bumps the top pointer without filling it
+                void bump(std::size_t offset) noexcept
+                {
+                    cur_ += offset;
+                }
+
+                // bumps the top pointer by offset and fills
+                void bump(std::size_t offset, debug_magic m) noexcept
+                {
+                    detail::debug_fill(cur_, offset, m);
+                    bump(offset);
+                }
+
+                // same as bump(offset, m) but returns old value
+                void* bump_return(std::size_t offset,
+                                  debug_magic m = debug_magic::new_memory) noexcept
+                {
+                    auto memory = cur_;
+                    detail::debug_fill(memory, offset, m);
+                    cur_ += offset;
+                    return memory;
+                }
+
+                // allocates memory by advancing the stack, returns nullptr if insufficient
+                // debug: mark memory as new_memory, put fence in front and back
+                void* allocate(const char* end, std::size_t size, std::size_t alignment,
+                               std::size_t fence_size = debug_fence_size) noexcept
+                {
+                    if (cur_ == nullptr)
+                        return nullptr;
+
+                    auto remaining = std::size_t(end - cur_);
+                    auto offset    = align_offset(cur_ + fence_size, alignment);
+                    if (fence_size + offset + size + fence_size > remaining)
+                        return nullptr;
+
+                    return allocate_unchecked(size, offset, fence_size);
+                }
+
+                // same as allocate() but does not check the size
+                // note: pass it the align OFFSET, not the alignment
+                void* allocate_unchecked(std::size_t size, std::size_t align_offset,
+                                         std::size_t fence_size = debug_fence_size) noexcept
+                {
+                    bump(fence_size, debug_magic::fence_memory);
+                    bump(align_offset, debug_magic::alignment_memory);
+                    auto mem = bump_return(size);
+                    bump(fence_size, debug_magic::fence_memory);
+                    return mem;
+                }
+
+                // unwindws the stack to a certain older position
+                // debug: marks memory from new top to old top as freed
+                // doesn't check for invalid pointer
+                void unwind(char* top) noexcept
+                {
+                    debug_fill(top, std::size_t(cur_ - top), debug_magic::freed_memory);
+                    cur_ = top;
+                }
+
+                // returns the current top
+                char* top() const noexcept
+                {
+                    return cur_;
+                }
+
+            private:
+                char* cur_;
+            };
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_MEMORY_STACK_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/small_free_list.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/small_free_list.hpp
new file mode 100644
index 0000000..682417d
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/small_free_list.hpp
@@ -0,0 +1,164 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_SMALL_FREE_LIST_HPP_INCLUDED
+#define WPI_MEMORY_DETAIL_SMALL_FREE_LIST_HPP_INCLUDED
+
+#include <cstddef>
+#include <climits>
+
+#include "../config.hpp"
+#include "utility.hpp"
+#include "align.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            struct chunk_base
+            {
+                chunk_base* prev = this;
+                chunk_base* next = this;
+
+                unsigned char first_free = 0; // first free node for the linked list
+                unsigned char capacity   = 0; // total number of free nodes available
+                unsigned char no_nodes   = 0; // total number of nodes in memory
+
+                chunk_base() noexcept = default;
+
+                chunk_base(unsigned char no) noexcept : capacity(no), no_nodes(no) {}
+            };
+
+            constexpr std::size_t chunk_memory_offset =
+                sizeof(chunk_base) % detail::max_alignment == 0 ?
+                    sizeof(chunk_base) :
+                    (sizeof(chunk_base) / detail::max_alignment + 1) * detail::max_alignment;
+            constexpr std::size_t chunk_max_nodes = UCHAR_MAX;
+
+            struct chunk;
+
+            // the same as free_memory_list but optimized for small node sizes
+            // it is slower and does not support arrays
+            // but has very small overhead
+            // debug: allocate() and deallocate() mark memory as new and freed, respectively
+            // node_size is increased via two times fence size and fence is put in front and after
+            class small_free_memory_list
+            {
+                static constexpr std::size_t chunk_count(std::size_t number_of_nodes)
+                {
+                    return number_of_nodes / chunk_max_nodes
+                           + (number_of_nodes % chunk_max_nodes == 0 ? 0 : 1);
+                }
+
+            public:
+                // minimum element size
+                static constexpr std::size_t min_element_size = 1;
+                // alignment
+                static constexpr std::size_t min_element_alignment = 1;
+
+                // minimal size of the block that needs to be inserted
+                static constexpr std::size_t min_block_size(std::size_t node_size,
+                                                            std::size_t number_of_nodes)
+                {
+                    return chunk_count(number_of_nodes)
+                           * (chunk_memory_offset + chunk_max_nodes * node_size);
+                }
+
+                //=== constructor ===//
+                small_free_memory_list(std::size_t node_size) noexcept;
+
+                // does not own memory!
+                small_free_memory_list(std::size_t node_size, void* mem, std::size_t size) noexcept;
+
+                small_free_memory_list(small_free_memory_list&& other) noexcept;
+
+                ~small_free_memory_list() noexcept = default;
+
+                small_free_memory_list& operator=(small_free_memory_list&& other) noexcept
+                {
+                    small_free_memory_list tmp(detail::move(other));
+                    swap(*this, tmp);
+                    return *this;
+                }
+
+                friend void swap(small_free_memory_list& a, small_free_memory_list& b) noexcept;
+
+                //=== insert/alloc/dealloc ===//
+                // inserts new memory of given size into the free list
+                // mem must be aligned for maximum alignment
+                void insert(void* mem, std::size_t size) noexcept;
+
+                // returns the usable size
+                // i.e. how many memory will be actually inserted and usable on a call to insert()
+                std::size_t usable_size(std::size_t size) const noexcept;
+
+                // allocates a node big enough for the node size
+                // pre: !empty()
+                void* allocate() noexcept;
+
+                // always returns nullptr, because array allocations are not supported
+                void* allocate(std::size_t) noexcept
+                {
+                    return nullptr;
+                }
+
+                // deallocates the node previously allocated via allocate()
+                void deallocate(void* node) noexcept;
+
+                // forwards to insert()
+                void deallocate(void* mem, std::size_t size) noexcept
+                {
+                    insert(mem, size);
+                }
+
+                // hint for allocate() to be prepared to allocate n nodes
+                // it searches for a chunk that has n nodes free
+                // returns false, if there is none like that
+                // never fails for n == 1 if not empty()
+                // pre: capacity() >= n * node_size()
+                bool find_chunk(std::size_t n) noexcept
+                {
+                    return find_chunk_impl(n) != nullptr;
+                }
+
+                //=== getter ===//
+                std::size_t node_size() const noexcept
+                {
+                    return node_size_;
+                }
+
+                // the alignment of all nodes
+                std::size_t alignment() const noexcept;
+
+                // number of nodes remaining
+                std::size_t capacity() const noexcept
+                {
+                    return capacity_;
+                }
+
+                bool empty() const noexcept
+                {
+                    return capacity_ == 0u;
+                }
+
+            private:
+                chunk* find_chunk_impl(std::size_t n = 1) noexcept;
+                chunk* find_chunk_impl(unsigned char* node, chunk_base* first,
+                                       chunk_base* last) noexcept;
+                chunk* find_chunk_impl(unsigned char* node) noexcept;
+
+                chunk_base  base_;
+                std::size_t node_size_, capacity_;
+                chunk_base *alloc_chunk_, *dealloc_chunk_;
+            };
+
+            // for some reason, this is required in order to define it
+            void swap(small_free_memory_list& a, small_free_memory_list& b) noexcept;
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_DETAIL_SMALL_FREE_LIST_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/utility.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/utility.hpp
new file mode 100644
index 0000000..c746fa2
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/detail/utility.hpp
@@ -0,0 +1,118 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_DETAIL_UTILITY_HPP
+#define WPI_MEMORY_DETAIL_UTILITY_HPP
+
+// implementation of some functions from <utility> to prevent dependencies on it
+
+#include <type_traits>
+
+#include "../config.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <utility>
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            // move - taken from http://stackoverflow.com/a/7518365
+            template <typename T>
+            typename std::remove_reference<T>::type&& move(T&& arg) noexcept
+            {
+                return static_cast<typename std::remove_reference<T>::type&&>(arg);
+            }
+            // forward - taken from http://stackoverflow.com/a/27501759
+            template <class T>
+            T&& forward(typename std::remove_reference<T>::type& t) noexcept
+            {
+                return static_cast<T&&>(t);
+            }
+            template <class T>
+            T&& forward(typename std::remove_reference<T>::type&& t) noexcept
+            {
+                static_assert(!std::is_lvalue_reference<T>::value,
+                              "Can not forward an rvalue as an lvalue.");
+                return static_cast<T&&>(t);
+            }
+
+            namespace swap_
+            {
+#if WPI_HOSTED_IMPLEMENTATION
+                using std::swap;
+#else
+                template <typename T>
+                void swap(T& a, T& b)
+                {
+                    T tmp = move(a);
+                    a     = move(b);
+                    b     = move(tmp);
+                }
+#endif
+            } // namespace swap_
+
+            // ADL aware swap
+            template <typename T>
+            void adl_swap(T& a, T& b) noexcept
+            {
+                using swap_::swap;
+                swap(a, b);
+            }
+
+// fancier syntax for enable_if
+// used as (template) parameter
+// also useful for doxygen
+// define PREDEFINED: WPI_REQUIRES(x):=
+#define WPI_REQUIRES(Expr) typename std::enable_if<(Expr), int>::type = 0
+
+// same as above, but as return type
+// also useful for doxygen:
+// defined PREDEFINED: WPI_REQUIRES_RET(x,r):=r
+#define WPI_REQUIRES_RET(Expr, ...) typename std::enable_if<(Expr), __VA_ARGS__>::type
+
+// fancier syntax for enable_if on non-templated member function
+#define WPI_ENABLE_IF(Expr)                                                                  \
+    template <typename Dummy = std::true_type, WPI_REQUIRES(Dummy::value && (Expr))>
+
+// fancier syntax for general expression SFINAE
+// used as (template) parameter
+// also useful for doxygen:
+// define PREDEFINED: WPI_SFINAE(x):=
+#define WPI_SFINAE(Expr) decltype((Expr), int()) = 0
+
+// avoids code repetition for one-line forwarding functions
+#define WPI_AUTO_RETURN(Expr)                                                                \
+    decltype(Expr)                                                                                 \
+    {                                                                                              \
+        return Expr;                                                                               \
+    }
+
+// same as above, but requires certain type
+#define WPI_AUTO_RETURN_TYPE(Expr, T)                                                        \
+    decltype(Expr)                                                                                 \
+    {                                                                                              \
+        static_assert(std::is_same<decltype(Expr), T>::value,                                      \
+                      #Expr " does not have the return type " #T);                                 \
+        return Expr;                                                                               \
+    }
+
+            // whether or not a type is an instantiation of a template
+            template <template <typename...> class Template, typename T>
+            struct is_instantiation_of : std::false_type
+            {
+            };
+
+            template <template <typename...> class Template, typename... Args>
+            struct is_instantiation_of<Template, Template<Args...>> : std::true_type
+            {
+            };
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_DETAIL_UTILITY_HPP
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/error.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/error.hpp
new file mode 100644
index 0000000..5ff99cf
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/error.hpp
@@ -0,0 +1,289 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+/// \file
+/// The exception classes.
+
+#ifndef WPI_MEMORY_ERROR_HPP_INCLUDED
+#define WPI_MEMORY_ERROR_HPP_INCLUDED
+
+#include <cstddef>
+#include <new>
+
+#include "config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// Contains information about an allocator.
+        /// It can be used for logging in the various handler functions.
+        /// \ingroup core
+        struct allocator_info
+        {
+            /// The name of the allocator.
+            /// It is a NTBS whose lifetime is not managed by this object,
+            /// it must be stored elsewhere or be a string literal.
+            const char* name;
+
+            /// A pointer representing an allocator.
+            /// It does not necessarily point to the beginning of the allocator object,
+            /// the only guarantee is that different allocator objects result in a different pointer value.
+            /// For stateless allocators it is sometimes \c nullptr.
+            /// \note The pointer must not be cast back to any allocator type.
+            const void* allocator;
+
+            /// \effects Creates it by giving it the name of the allocator and a pointer.
+            constexpr allocator_info(const char* n, const void* alloc) noexcept
+            : name(n), allocator(alloc)
+            {
+            }
+
+            /// @{
+            /// \effects Compares two \ref allocator_info objects, they are equal, if the \ref allocator is the same.
+            /// \returns The result of the comparision.
+            friend constexpr bool operator==(const allocator_info& a,
+                                             const allocator_info& b) noexcept
+            {
+                return a.allocator == b.allocator;
+            }
+
+            friend constexpr bool operator!=(const allocator_info& a,
+                                             const allocator_info& b) noexcept
+            {
+                return a.allocator != b.allocator;
+            }
+            /// @}
+        };
+
+        /// The exception class thrown when a low level allocator runs out of memory.
+        /// It is derived from \c std::bad_alloc.
+        /// This can happen if a low level allocation function like \c std::malloc() runs out of memory.
+        /// Throwing can be prohibited by the handler function.
+        /// \ingroup core
+        class out_of_memory : public std::bad_alloc
+        {
+        public:
+            /// The type of the handler called in the constructor of \ref out_of_memory.
+            /// When an out of memory situation is encountered and the exception class created,
+            /// this handler gets called.
+            /// It is especially useful if exception support is disabled.
+            /// It gets the \ref allocator_info and the amount of memory that was tried to be allocated.
+            /// \requiredbe It can log the error, throw a different exception derived from \c std::bad_alloc or abort the program.
+            /// If it returns, this exception object will be created and thrown.
+            /// \defaultbe On a hosted implementation it logs the error on \c stderr and continues execution,
+            /// leading to this exception being thrown.
+            /// On a freestanding implementation it does nothing.
+            /// \note It is different from \c std::new_handler; it will not be called in a loop trying to allocate memory
+            /// or something like that. Its only job is to report the error.
+            using handler = void (*)(const allocator_info& info, std::size_t amount);
+
+            /// \effects Sets \c h as the new \ref handler in an atomic operation.
+            /// A \c nullptr sets the default \ref handler.
+            /// \returns The previous \ref handler. This is never \c nullptr.
+            static handler set_handler(handler h);
+
+            /// \returns The current \ref handler. This is never \c nullptr.
+            static handler get_handler();
+
+            /// \effects Creates it by passing it the \ref allocator_info and the amount of memory failed to be allocated.
+            /// It also calls the \ref handler to control whether or not it will be thrown.
+            out_of_memory(const allocator_info& info, std::size_t amount);
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+
+            /// \returns The \ref allocator_info passed to it in the constructor.
+            const allocator_info& allocator() const noexcept
+            {
+                return info_;
+            }
+
+            /// \returns The amount of memory that was tried to be allocated.
+            /// This is the value passed in the constructor.
+            std::size_t failed_allocation_size() const noexcept
+            {
+                return amount_;
+            }
+
+        private:
+            allocator_info info_;
+            std::size_t    amount_;
+        };
+
+        /// A special case of \ref out_of_memory errors
+        /// thrown when a low-level allocator with a fixed size runs out of memory.
+        /// For example, thrown by \ref fixed_block_allocator or \ref static_allocator.<br>
+        /// It is derived from \ref out_of_memory but does not provide its own handler.
+        /// \ingroup core
+        class out_of_fixed_memory : public out_of_memory
+        {
+        public:
+            /// \effects Just forwards to \ref out_of_memory.
+            out_of_fixed_memory(const allocator_info& info, std::size_t amount)
+            : out_of_memory(info, amount)
+            {
+            }
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+        };
+
+        /// The exception class thrown when an allocation size is bigger than the supported maximum.
+        /// This size is either the node, array or alignment parameter in a call to an allocation function.
+        /// If those exceed the supported maximum returned by \c max_node_size(), \c max_array_size() or \c max_alignment(),
+        /// one of its derived classes will be thrown or this class if in a situation where the type is unknown.
+        /// It is derived from \c std::bad_alloc.
+        /// Throwing can be prohibited by the handler function.
+        /// \note Even if all parameters are less than the maximum, \ref out_of_memory or a similar exception can be thrown,
+        /// because the maximum functions return an upper bound and not the actual supported maximum size,
+        /// since it always depends on fence memory, alignment buffer and the like.
+        /// \note A user should only \c catch for \c bad_allocation_size, not the derived classes.
+        /// \note Most checks will only be done if \ref WPI_MEMORY_CHECK_ALLOCATION_SIZE is \c true.
+        /// \ingroup core
+        class bad_allocation_size : public std::bad_alloc
+        {
+        public:
+            /// The type of the handler called in the constructor of \ref bad_allocation_size.
+            /// When a bad allocation size is detected and the exception object created,
+            /// this handler gets called.
+            /// It is especially useful if exception support is disabled.
+            /// It gets the \ref allocator_info, the size passed to the function and the supported size
+            /// (the latter is still an upper bound).
+            /// \requiredbe It can log the error, throw a different exception derived from \c std::bad_alloc or abort the program.
+            /// If it returns, this exception object will be created and thrown.
+            /// \defaultbe On a hosted implementation it logs the error on \c stderr and continues execution,
+            /// leading to this exception being thrown.
+            /// On a freestanding implementation it does nothing.
+            using handler = void (*)(const allocator_info& info, std::size_t passed,
+                                     std::size_t supported);
+
+            /// \effects Sets \c h as the new \ref handler in an atomic operation.
+            /// A \c nullptr sets the default \ref handler.
+            /// \returns The previous \ref handler. This is never \c nullptr.
+            static handler set_handler(handler h);
+
+            /// \returns The current \ref handler. This is never \c nullptr.
+            static handler get_handler();
+
+            /// \effects Creates it by passing it the \ref allocator_info, the size passed to the allocation function
+            /// and an upper bound on the supported size.
+            /// It also calls the \ref handler to control whether or not it will be thrown.
+            bad_allocation_size(const allocator_info& info, std::size_t passed,
+                                std::size_t supported);
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+
+            /// \returns The \ref allocator_info passed to it in the constructor.
+            const allocator_info& allocator() const noexcept
+            {
+                return info_;
+            }
+
+            /// \returns The size or alignment value that was passed to the allocation function
+            /// which was too big. This is the same value passed to the constructor.
+            std::size_t passed_value() const noexcept
+            {
+                return passed_;
+            }
+
+            /// \returns An upper bound on the maximum supported size/alignment.
+            /// It is only an upper bound, values below can fail, but values above will always fail.
+            std::size_t supported_value() const noexcept
+            {
+                return supported_;
+            }
+
+        private:
+            allocator_info info_;
+            std::size_t    passed_, supported_;
+        };
+
+        /// The exception class thrown when the node size exceeds the supported maximum,
+        /// i.e. it is bigger than \c max_node_size().
+        /// It is derived from \ref bad_allocation_size but does not override the handler.
+        /// \ingroup core
+        class bad_node_size : public bad_allocation_size
+        {
+        public:
+            /// \effects Just forwards to \ref bad_allocation_size.
+            bad_node_size(const allocator_info& info, std::size_t passed, std::size_t supported)
+            : bad_allocation_size(info, passed, supported)
+            {
+            }
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+        };
+
+        /// The exception class thrown when the array size exceeds the supported maximum,
+        /// i.e. it is bigger than \c max_array_size().
+        /// It is derived from \ref bad_allocation_size but does not override the handler.
+        /// \ingroup core
+        class bad_array_size : public bad_allocation_size
+        {
+        public:
+            /// \effects Just forwards to \ref bad_allocation_size.
+            bad_array_size(const allocator_info& info, std::size_t passed, std::size_t supported)
+            : bad_allocation_size(info, passed, supported)
+            {
+            }
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+        };
+
+        /// The exception class thrown when the alignment exceeds the supported maximum,
+        /// i.e. it is bigger than \c max_alignment().
+        /// It is derived from \ref bad_allocation_size but does not override the handler.
+        /// \ingroup core
+        class bad_alignment : public bad_allocation_size
+        {
+        public:
+            /// \effects Just forwards to \ref bad_allocation_size.
+            /// \c passed is <tt>count * size</tt>, \c supported the size in bytes.
+            bad_alignment(const allocator_info& info, std::size_t passed, std::size_t supported)
+            : bad_allocation_size(info, passed, supported)
+            {
+            }
+
+            /// \returns A static NTBS that describes the error.
+            /// It does not contain any specific information since there is no memory for formatting.
+            const char* what() const noexcept override;
+        };
+
+        namespace detail
+        {
+            template <class Ex, typename Func>
+            void check_allocation_size(std::size_t passed, Func f, const allocator_info& info)
+            {
+#if WPI_MEMORY_CHECK_ALLOCATION_SIZE
+                auto supported = f();
+                if (passed > supported)
+                    WPI_THROW(Ex(info, passed, supported));
+#else
+                (void)passed;
+                (void)f;
+                (void)info;
+#endif
+            }
+
+            template <class Ex>
+            void check_allocation_size(std::size_t passed, std::size_t supported,
+                                       const allocator_info& info)
+            {
+                check_allocation_size<Ex>(
+                    passed, [&] { return supported; }, info);
+            }
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_ERROR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/fallback_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/fallback_allocator.hpp
new file mode 100644
index 0000000..3bf530e
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/fallback_allocator.hpp
@@ -0,0 +1,212 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_FALLBACK_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_FALLBACK_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+//// Class template \ref wpi::memory::fallback_allocator.
+
+#include "detail/ebo_storage.hpp"
+#include "detail/utility.hpp"
+#include "allocator_traits.hpp"
+#include "config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A \concept{raw_allocator,RawAllocator} with a fallback.
+        /// Allocation first tries `Default`, if it fails,
+        /// it uses `Fallback`.
+        /// \requires `Default` must be a composable \concept{concept_rawallocator,RawAllocator},
+        /// `Fallback` must be a \concept{concept_rawallocator,RawAllocator}.
+        /// \ingroup adapter
+        template <class Default, class Fallback>
+        class fallback_allocator
+        : WPI_EBO(detail::ebo_storage<0, typename allocator_traits<Default>::allocator_type>),
+          WPI_EBO(detail::ebo_storage<1, typename allocator_traits<Fallback>::allocator_type>)
+        {
+            using default_traits             = allocator_traits<Default>;
+            using default_composable_traits  = composable_allocator_traits<Default>;
+            using fallback_traits            = allocator_traits<Fallback>;
+            using fallback_composable_traits = composable_allocator_traits<Fallback>;
+            using fallback_composable =
+                is_composable_allocator<typename fallback_traits::allocator_type>;
+
+        public:
+            using default_allocator_type  = typename allocator_traits<Default>::allocator_type;
+            using fallback_allocator_type = typename allocator_traits<Fallback>::allocator_type;
+
+            using is_stateful =
+                std::integral_constant<bool, default_traits::is_stateful::value
+                                                 || fallback_traits::is_stateful::value>;
+
+            /// \effects Default constructs both allocators.
+            /// \notes This function only participates in overload resolution, if both allocators are not stateful.
+            WPI_ENABLE_IF(!is_stateful::value)
+            fallback_allocator()
+            : detail::ebo_storage<0, default_allocator_type>({}),
+              detail::ebo_storage<1, fallback_allocator_type>({})
+            {
+            }
+
+            /// \effects Constructs the allocator by passing in the two allocators it has.
+            explicit fallback_allocator(default_allocator_type&&  default_alloc,
+                                        fallback_allocator_type&& fallback_alloc = {})
+            : detail::ebo_storage<0, default_allocator_type>(detail::move(default_alloc)),
+              detail::ebo_storage<1, fallback_allocator_type>(detail::move(fallback_alloc))
+            {
+            }
+
+            /// @{
+            /// \effects First calls the compositioning (de)allocation function on the `default_allocator_type`.
+            /// If that fails, uses the non-compositioning function of the `fallback_allocator_type`.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                auto ptr = default_composable_traits::try_allocate_node(get_default_allocator(),
+                                                                        size, alignment);
+                if (!ptr)
+                    ptr = fallback_traits::allocate_node(get_fallback_allocator(), size, alignment);
+                return ptr;
+            }
+
+            void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+            {
+                auto ptr = default_composable_traits::try_allocate_array(get_default_allocator(),
+                                                                         count, size, alignment);
+                if (!ptr)
+                    ptr = fallback_traits::allocate_array(get_fallback_allocator(), count, size,
+                                                          alignment);
+                return ptr;
+            }
+
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                auto res = default_composable_traits::try_deallocate_node(get_default_allocator(),
+                                                                          ptr, size, alignment);
+                if (!res)
+                    fallback_traits::deallocate_node(get_fallback_allocator(), ptr, size,
+                                                     alignment);
+            }
+
+            void deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                  std::size_t alignment) noexcept
+            {
+                auto res =
+                    default_composable_traits::try_deallocate_array(get_default_allocator(), ptr,
+                                                                    count, size, alignment);
+                if (!res)
+                    fallback_traits::deallocate_array(get_fallback_allocator(), ptr, count, size,
+                                                      alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \effects First calls the compositioning (de)allocation function on the `default_allocator_type`.
+            /// If that fails, uses the compositioning function of the `fallback_allocator_type`.
+            /// \requires The `fallback_allocator_type` msut be composable.
+            WPI_ENABLE_IF(fallback_composable::value)
+            void* try_allocate_node(std::size_t size, std::size_t alignment) noexcept
+            {
+                auto ptr = default_composable_traits::try_allocate_node(get_default_allocator(),
+                                                                        size, alignment);
+                if (!ptr)
+                    ptr = fallback_composable_traits::try_allocate_node(get_fallback_allocator(),
+                                                                        size, alignment);
+                return ptr;
+            }
+
+            WPI_ENABLE_IF(fallback_composable::value)
+            void* allocate_array(std::size_t count, std::size_t size,
+                                 std::size_t alignment) noexcept
+            {
+                auto ptr = default_composable_traits::try_allocate_array(get_default_allocator(),
+                                                                         count, size, alignment);
+                if (!ptr)
+                    ptr = fallback_composable_traits::try_allocate_array(get_fallback_allocator(),
+                                                                         count, size, alignment);
+                return ptr;
+            }
+
+            WPI_ENABLE_IF(fallback_composable::value)
+            bool try_deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                auto res = default_composable_traits::try_deallocate_node(get_default_allocator(),
+                                                                          ptr, size, alignment);
+                if (!res)
+                    res = fallback_composable_traits::try_deallocate_node(get_fallback_allocator(),
+                                                                          ptr, size, alignment);
+                return res;
+            }
+
+            WPI_ENABLE_IF(fallback_composable::value)
+            bool try_deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                      std::size_t alignment) noexcept
+            {
+                auto res =
+                    default_composable_traits::try_deallocate_array(get_default_allocator(), ptr,
+                                                                    count, size, alignment);
+                if (!res)
+                    res = fallback_composable_traits::try_deallocate_array(get_fallback_allocator(),
+                                                                           ptr, count, size,
+                                                                           alignment);
+                return res;
+            }
+            /// @}
+
+            /// @{
+            /// \returns The maximum of the two values from both allocators.
+            std::size_t max_node_size() const
+            {
+                auto def      = default_traits::max_node_size(get_default_allocator());
+                auto fallback = fallback_traits::max_node_size(get_fallback_allocator());
+                return fallback > def ? fallback : def;
+            }
+
+            std::size_t max_array_size() const
+            {
+                auto def      = default_traits::max_array_size(get_default_allocator());
+                auto fallback = fallback_traits::max_array_size(get_fallback_allocator());
+                return fallback > def ? fallback : def;
+            }
+
+            std::size_t max_alignment() const
+            {
+                auto def      = default_traits::max_alignment(get_default_allocator());
+                auto fallback = fallback_traits::max_alignment(get_fallback_allocator());
+                return fallback > def ? fallback : def;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (`const`) reference to the default allocator.
+            default_allocator_type& get_default_allocator() noexcept
+            {
+                return detail::ebo_storage<0, default_allocator_type>::get();
+            }
+
+            const default_allocator_type& get_default_allocator() const noexcept
+            {
+                return detail::ebo_storage<0, default_allocator_type>::get();
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (`const`) reference to the fallback allocator.
+            fallback_allocator_type& get_fallback_allocator() noexcept
+            {
+                return detail::ebo_storage<1, fallback_allocator_type>::get();
+            }
+
+            const fallback_allocator_type& get_fallback_allocator() const noexcept
+            {
+                return detail::ebo_storage<1, fallback_allocator_type>::get();
+            }
+            /// @}
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_FALLBACK_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/heap_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/heap_allocator.hpp
new file mode 100644
index 0000000..0724937
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/heap_allocator.hpp
@@ -0,0 +1,83 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_HEAP_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_HEAP_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::heap_allocator and related functions.
+
+#include "detail/lowlevel_allocator.hpp"
+#include "config.hpp"
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+#include "allocator_traits.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        struct allocator_info;
+
+        /// Allocates heap memory.
+        /// This function is used by the \ref heap_allocator to allocate the heap memory.
+        /// It is not defined on a freestanding implementation, a definition must be provided by the library user.
+        /// \requiredbe This function shall return a block of uninitialized memory that is aligned for \c max_align_t and has the given size.
+        /// The size parameter will not be zero.
+        /// It shall return a \c nullptr if no memory is available.
+        /// It must be thread safe.
+        /// \defaultbe On a hosted implementation this function uses OS specific facilities, \c std::malloc is used as fallback.
+        /// \ingroup allocator
+        void* heap_alloc(std::size_t size) noexcept;
+
+        /// Deallocates heap memory.
+        /// This function is used by the \ref heap_allocator to allocate the heap memory.
+        /// It is not defined on a freestanding implementation, a definition must be provided by the library user.
+        /// \requiredbe This function gets a pointer from a previous call to \ref heap_alloc with the same size.
+        /// It shall free the memory.
+        /// The pointer will not be zero.
+        /// It must be thread safe.
+        /// \defaultbe On a hosted implementation this function uses OS specific facilities, \c std::free is used as fallback.
+        /// \ingroup allocator
+        void heap_dealloc(void* ptr, std::size_t size) noexcept;
+
+        namespace detail
+        {
+            struct heap_allocator_impl
+            {
+                static allocator_info info() noexcept;
+
+                static void* allocate(std::size_t size, std::size_t) noexcept
+                {
+                    return heap_alloc(size);
+                }
+
+                static void deallocate(void* ptr, std::size_t size, std::size_t) noexcept
+                {
+                    heap_dealloc(ptr, size);
+                }
+
+                static std::size_t max_node_size() noexcept;
+            };
+
+            WPI_MEMORY_LL_ALLOCATOR_LEAK_CHECKER(heap_allocator_impl,
+                                                       heap_alloator_leak_checker)
+        } // namespace detail
+
+        /// A stateless \concept{concept_rawallocator,RawAllocator} that allocates memory from the heap.
+        /// It uses the two functions \ref heap_alloc and \ref heap_dealloc for the allocation,
+        /// which default to \c std::malloc and \c std::free.
+        /// \ingroup allocator
+        using heap_allocator =
+            WPI_IMPL_DEFINED(detail::lowlevel_allocator<detail::heap_allocator_impl>);
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class detail::lowlevel_allocator<detail::heap_allocator_impl>;
+        extern template class allocator_traits<heap_allocator>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_HEAP_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/iteration_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/iteration_allocator.hpp
new file mode 100644
index 0000000..d35a927
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/iteration_allocator.hpp
@@ -0,0 +1,305 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_ITERATION_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_ITERATION_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class template \ref wpi::memory::iteration_allocator.
+
+#include "detail/debug_helpers.hpp"
+#include "detail/memory_stack.hpp"
+#include "default_allocator.hpp"
+#include "error.hpp"
+#include "memory_arena.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <class BlockOrRawAllocator>
+            using iteration_block_allocator =
+                make_block_allocator_t<BlockOrRawAllocator, fixed_block_allocator>;
+        } // namespace detail
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that is designed for allocations in a loop.
+        /// It uses `N` stacks for the allocation, one of them is always active.
+        /// Allocation uses the currently active stack.
+        /// Calling \ref iteration_allocator::next_iteration() at the end of the loop,
+        /// will make the next stack active for allocation,
+        /// effectively releasing all of its memory.
+        /// Any memory allocated will thus be usable for `N` iterations of the loop.
+        /// This type of allocator is a generalization of the double frame allocator.
+        /// \ingroup allocator
+        template <std::size_t N, class BlockOrRawAllocator = default_allocator>
+        class iteration_allocator
+        : WPI_EBO(detail::iteration_block_allocator<BlockOrRawAllocator>)
+        {
+        public:
+            using allocator_type = detail::iteration_block_allocator<BlockOrRawAllocator>;
+
+            /// \effects Creates it with a given initial block size and and other constructor arguments for the \concept{concept_blockallocator,BlockAllocator}.
+            /// It will allocate the first (and only) block and evenly divide it on all the stacks it uses.
+            template <typename... Args>
+            explicit iteration_allocator(std::size_t block_size, Args&&... args)
+            : allocator_type(block_size, detail::forward<Args>(args)...), cur_(0u)
+            {
+                block_         = get_allocator().allocate_block();
+                auto cur       = static_cast<char*>(block_.memory);
+                auto size_each = block_.size / N;
+                for (auto i = 0u; i != N; ++i)
+                {
+                    stacks_[i] = detail::fixed_memory_stack(cur);
+                    cur += size_each;
+                }
+            }
+
+            iteration_allocator(iteration_allocator&& other) noexcept
+            : allocator_type(detail::move(other)),
+              block_(other.block_),
+              cur_(detail::move(other.cur_))
+            {
+                for (auto i = 0u; i != N; ++i)
+                    stacks_[i] = detail::move(other.stacks_[i]);
+
+                other.cur_ = N;
+            }
+
+            ~iteration_allocator() noexcept
+            {
+                if (cur_ < N)
+                    get_allocator().deallocate_block(block_);
+            }
+
+            iteration_allocator& operator=(iteration_allocator&& other) noexcept
+            {
+                allocator_type::operator=(detail::move(other));
+                block_                  = other.block_;
+                cur_                    = other.cur_;
+
+                for (auto i = 0u; i != N; ++i)
+                    stacks_[i] = detail::move(other.stacks_[i]);
+
+                other.cur_ = N;
+
+                return *this;
+            }
+
+            /// \effects Allocates a memory block of given size and alignment.
+            /// It simply moves the top marker of the currently active stack.
+            /// \returns A \concept{concept_node,node} with given size and alignment.
+            /// \throws \ref out_of_fixed_memory if the current stack does not have any memory left.
+            /// \requires \c size and \c alignment must be valid.
+            void* allocate(std::size_t size, std::size_t alignment)
+            {
+                auto& stack = stacks_[cur_];
+
+                auto fence  = detail::debug_fence_size;
+                auto offset = detail::align_offset(stack.top() + fence, alignment);
+                if (!stack.top()
+                    || (fence + offset + size + fence > std::size_t(block_end(cur_) - stack.top())))
+                    WPI_THROW(out_of_fixed_memory(info(), size));
+                return stack.allocate_unchecked(size, offset);
+            }
+
+            /// \effects Allocates a memory block of given size and alignment
+            /// similar to \ref allocate().
+            /// \returns A \concept{concept_node,node} with given size and alignment
+            /// or `nullptr` if the current stack does not have any memory left.
+            void* try_allocate(std::size_t size, std::size_t alignment) noexcept
+            {
+                auto& stack = stacks_[cur_];
+                return stack.allocate(block_end(cur_), size, alignment);
+            }
+
+            /// \effects Goes to the next internal stack.
+            /// This will clear the stack whose \ref max_iterations() lifetime has reached,
+            /// and use it for all allocations in this iteration.
+            /// \note This function should be called at the end of the loop.
+            void next_iteration() noexcept
+            {
+                WPI_MEMORY_ASSERT_MSG(cur_ != N, "moved-from allocator");
+                cur_ = (cur_ + 1) % N;
+                stacks_[cur_].unwind(block_start(cur_));
+            }
+
+            /// \returns The number of iteration each allocation will live.
+            /// This is the template parameter `N`.
+            static std::size_t max_iterations() noexcept
+            {
+                return N;
+            }
+
+            /// \returns The index of the current iteration.
+            /// This is modulo \ref max_iterations().
+            std::size_t cur_iteration() const noexcept
+            {
+                return cur_;
+            }
+
+            /// \returns A reference to the \concept{concept_blockallocator,BlockAllocator} used for managing the memory.
+            /// \requires It is undefined behavior to move this allocator out into another object.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            /// \returns The amount of memory remaining in the stack with the given index.
+            /// This is the number of bytes that are available for allocation.
+            std::size_t capacity_left(std::size_t i) const noexcept
+            {
+                return std::size_t(block_end(i) - stacks_[i].top());
+            }
+
+            /// \returns The amount of memory remaining in the currently active stack.
+            std::size_t capacity_left() const noexcept
+            {
+                return capacity_left(cur_iteration());
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::iteration_allocator", this};
+            }
+
+            char* block_start(std::size_t i) const noexcept
+            {
+                WPI_MEMORY_ASSERT_MSG(i <= N, "moved from state");
+                auto ptr = static_cast<char*>(block_.memory);
+                return ptr + (i * block_.size / N);
+            }
+
+            char* block_end(std::size_t i) const noexcept
+            {
+                WPI_MEMORY_ASSERT_MSG(i < N, "moved from state");
+                return block_start(i + 1);
+            }
+
+            detail::fixed_memory_stack stacks_[N];
+            memory_block               block_;
+            std::size_t                cur_;
+
+            friend allocator_traits<iteration_allocator<N, BlockOrRawAllocator>>;
+            friend composable_allocator_traits<iteration_allocator<N, BlockOrRawAllocator>>;
+        };
+
+        /// An alias for \ref iteration_allocator for two iterations.
+        /// \ingroup allocator
+        template <class BlockOrRawAllocator = default_allocator>
+        WPI_ALIAS_TEMPLATE(double_frame_allocator,
+                                 iteration_allocator<2, BlockOrRawAllocator>);
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class iteration_allocator<2>;
+#endif
+
+        /// Specialization of the \ref allocator_traits for \ref iteration_allocator.
+        /// \note It is not allowed to mix calls through the specialization and through the member functions,
+        /// i.e. \ref memory_stack::allocate() and this \c allocate_node().
+        /// \ingroup allocator
+        template <std::size_t N, class BlockAllocator>
+        class allocator_traits<iteration_allocator<N, BlockAllocator>>
+        {
+        public:
+            using allocator_type = iteration_allocator<N, BlockAllocator>;
+            using is_stateful    = std::true_type;
+
+            /// \returns The result of \ref iteration_allocator::allocate().
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                return state.allocate(size, alignment);
+            }
+
+            /// \returns The result of \ref memory_stack::allocate().
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                return allocate_node(state, count * size, alignment);
+            }
+
+            /// @{
+            /// \effects Does nothing.
+            /// Actual deallocation can only be done via \ref memory_stack::unwind().
+            static void deallocate_node(allocator_type&, void*, std::size_t, std::size_t) noexcept
+            {
+            }
+
+            static void deallocate_array(allocator_type&, void*, std::size_t, std::size_t,
+                                         std::size_t) noexcept
+            {
+            }
+            /// @}
+
+            /// @{
+            /// \returns The maximum size which is \ref iteration_allocator::capacity_left().
+            static std::size_t max_node_size(const allocator_type& state) noexcept
+            {
+                return state.capacity_left();
+            }
+
+            static std::size_t max_array_size(const allocator_type& state) noexcept
+            {
+                return state.capacity_left();
+            }
+            /// @}
+
+            /// \returns The maximum possible value since there is no alignment restriction
+            /// (except indirectly through \ref memory_stack::next_capacity()).
+            static std::size_t max_alignment(const allocator_type&) noexcept
+            {
+                return std::size_t(-1);
+            }
+        };
+
+        /// Specialization of the \ref composable_allocator_traits for \ref iteration_allocator classes.
+        /// \ingroup allocator
+        template <std::size_t N, class BlockAllocator>
+        class composable_allocator_traits<iteration_allocator<N, BlockAllocator>>
+        {
+        public:
+            using allocator_type = iteration_allocator<N, BlockAllocator>;
+
+            /// \returns The result of \ref memory_stack::try_allocate().
+            static void* try_allocate_node(allocator_type& state, std::size_t size,
+                                           std::size_t alignment) noexcept
+            {
+                return state.try_allocate(size, alignment);
+            }
+
+            /// \returns The result of \ref memory_stack::try_allocate().
+            static void* try_allocate_array(allocator_type& state, std::size_t count,
+                                            std::size_t size, std::size_t alignment) noexcept
+            {
+                return state.try_allocate(count * size, alignment);
+            }
+
+            /// @{
+            /// \effects Does nothing.
+            /// \returns Whether the memory will be deallocated by \ref memory_stack::unwind().
+            static bool try_deallocate_node(allocator_type& state, void* ptr, std::size_t,
+                                            std::size_t) noexcept
+            {
+                return state.block_.contains(ptr);
+            }
+
+            static bool try_deallocate_array(allocator_type& state, void* ptr, std::size_t count,
+                                             std::size_t size, std::size_t alignment) noexcept
+            {
+                return try_deallocate_node(state, ptr, count * size, alignment);
+            }
+            /// @}
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<iteration_allocator<2>>;
+        extern template class composable_allocator_traits<iteration_allocator<2>>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_ITERATION_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/joint_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/joint_allocator.hpp
new file mode 100644
index 0000000..db67d46
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/joint_allocator.hpp
@@ -0,0 +1,927 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_JOINT_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_JOINT_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class template \ref wpi::memory::joint_ptr, \ref wpi::memory::joint_allocator and related.
+
+#include <initializer_list>
+#include <new>
+
+#include "detail/align.hpp"
+#include "detail/memory_stack.hpp"
+#include "detail/utility.hpp"
+#include "allocator_storage.hpp"
+#include "config.hpp"
+#include "default_allocator.hpp"
+#include "error.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        template <typename T, class RawAllocator>
+        class joint_ptr;
+
+        template <typename T>
+        class joint_type;
+
+        namespace detail
+        {
+            // the stack that allocates the joint memory
+            class joint_stack
+            {
+            public:
+                joint_stack(void* mem, std::size_t cap) noexcept
+                : stack_(static_cast<char*>(mem)), end_(static_cast<char*>(mem) + cap)
+                {
+                }
+
+                void* allocate(std::size_t size, std::size_t alignment) noexcept
+                {
+                    return stack_.allocate(end_, size, alignment, 0u);
+                }
+
+                bool bump(std::size_t offset) noexcept
+                {
+                    if (offset > std::size_t(end_ - stack_.top()))
+                        return false;
+                    stack_.bump(offset);
+                    return true;
+                }
+
+                char* top() noexcept
+                {
+                    return stack_.top();
+                }
+
+                const char* top() const noexcept
+                {
+                    return stack_.top();
+                }
+
+                void unwind(void* ptr) noexcept
+                {
+                    stack_.unwind(static_cast<char*>(ptr));
+                }
+
+                std::size_t capacity(const char* mem) const noexcept
+                {
+                    return std::size_t(end_ - mem);
+                }
+
+                std::size_t capacity_left() const noexcept
+                {
+                    return std::size_t(end_ - top());
+                }
+
+                std::size_t capacity_used(const char* mem) const noexcept
+                {
+                    return std::size_t(top() - mem);
+                }
+
+            private:
+                detail::fixed_memory_stack stack_;
+                char*                      end_;
+            };
+
+            template <typename T>
+            detail::joint_stack& get_stack(joint_type<T>& obj) noexcept;
+
+            template <typename T>
+            const detail::joint_stack& get_stack(const joint_type<T>& obj) noexcept;
+        } // namespace detail
+
+        /// Tag type that can't be created.
+        ///
+        /// It isued by \ref joint_ptr.
+        /// \ingroup allocator
+        class joint
+        {
+            joint(std::size_t cap) noexcept : capacity(cap) {}
+
+            std::size_t capacity;
+
+            template <typename T, class RawAllocator>
+            friend class joint_ptr;
+            template <typename T>
+            friend class joint_type;
+        };
+
+        /// Tag type to make the joint size more explicit.
+        ///
+        /// It is used by \ref joint_ptr.
+        /// \ingroup allocator
+        struct joint_size
+        {
+            std::size_t size;
+
+            explicit joint_size(std::size_t s) noexcept : size(s) {}
+        };
+
+        /// CRTP base class for all objects that want to use joint memory.
+        ///
+        /// This will disable default copy/move operations
+        /// and inserts additional members for the joint memory management.
+        /// \ingroup allocator
+        template <typename T>
+        class joint_type
+        {
+        protected:
+            /// \effects Creates the base class,
+            /// the tag type cannot be created by the user.
+            /// \note This ensures that you cannot create joint types yourself.
+            joint_type(joint j) noexcept;
+
+            joint_type(const joint_type&) = delete;
+            joint_type(joint_type&&)      = delete;
+
+        private:
+            detail::joint_stack stack_;
+
+            template <typename U>
+            friend detail::joint_stack& detail::get_stack(joint_type<U>& obj) noexcept;
+            template <typename U>
+            friend const detail::joint_stack& detail::get_stack(const joint_type<U>& obj) noexcept;
+        };
+
+        namespace detail
+        {
+            template <typename T>
+            detail::joint_stack& get_stack(joint_type<T>& obj) noexcept
+            {
+                return obj.stack_;
+            }
+
+            template <typename T>
+            const detail::joint_stack& get_stack(const joint_type<T>& obj) noexcept
+            {
+                return obj.stack_;
+            }
+
+            template <typename T>
+            char* get_memory(joint_type<T>& obj) noexcept
+            {
+                auto mem = static_cast<void*>(&obj);
+                return static_cast<char*>(mem) + sizeof(T);
+            }
+
+            template <typename T>
+            const char* get_memory(const joint_type<T>& obj) noexcept
+            {
+                auto mem = static_cast<const void*>(&obj);
+                return static_cast<const char*>(mem) + sizeof(T);
+            }
+
+        } // namespace detail
+
+        template <typename T>
+        joint_type<T>::joint_type(joint j) noexcept : stack_(detail::get_memory(*this), j.capacity)
+        {
+            WPI_MEMORY_ASSERT(stack_.top() == detail::get_memory(*this));
+            WPI_MEMORY_ASSERT(stack_.capacity_left() == j.capacity);
+        }
+
+        /// A pointer to an object where all allocations are joint.
+        ///
+        /// It can either own an object or not (be `nullptr`).
+        /// When it owns an object, it points to a memory block.
+        /// This memory block contains both the actual object (of the type `T`)
+        /// and space for allocations of `T`s members.
+        ///
+        /// The type `T` must be derived from \ref joint_type and every constructor must take \ref joint
+        /// as first parameter.
+        /// This prevents that you create joint objects yourself,
+        /// without the additional storage.
+        /// The default copy and move constructors are also deleted,
+        /// you need to write them yourself.
+        ///
+        /// You can only access the object through the pointer,
+        /// use \ref joint_allocator or \ref joint_array as members of `T`,
+        /// to enable the memory sharing.
+        /// If you are using \ref joint_allocator inside STL containers,
+        /// make sure that you do not call their regular copy/move constructors,
+        /// but instead the version where you pass an allocator.
+        ///
+        /// The memory block will be managed by the given \concept{concept_rawallocator,RawAllocator},
+        /// it is stored in an \ref allocator_reference and not owned by the pointer directly.
+        /// \ingroup allocator
+        template <typename T, class RawAllocator>
+        class joint_ptr : WPI_EBO(allocator_reference<RawAllocator>)
+        {
+            static_assert(std::is_base_of<joint_type<T>, T>::value,
+                          "T must be derived of joint_type<T>");
+
+        public:
+            using element_type   = T;
+            using allocator_type = typename allocator_reference<RawAllocator>::allocator_type;
+
+            //=== constructors/destructor/assignment ===//
+            /// @{
+            /// \effects Creates it with a \concept{concept_rawallocator,RawAllocator}, but does not own a new object.
+            explicit joint_ptr(allocator_type& alloc) noexcept
+            : allocator_reference<RawAllocator>(alloc), ptr_(nullptr)
+            {
+            }
+
+            explicit joint_ptr(const allocator_type& alloc) noexcept
+            : allocator_reference<RawAllocator>(alloc), ptr_(nullptr)
+            {
+            }
+            /// @}
+
+            /// @{
+            /// \effects Reserves memory for the object and the additional size,
+            /// and creates the object by forwarding the arguments to its constructor.
+            /// The \concept{concept_rawallocator,RawAllocator} will be used for the allocation.
+            template <typename... Args>
+            joint_ptr(allocator_type& alloc, joint_size additional_size, Args&&... args)
+            : joint_ptr(alloc)
+            {
+                create(additional_size.size, detail::forward<Args>(args)...);
+            }
+
+            template <typename... Args>
+            joint_ptr(const allocator_type& alloc, joint_size additional_size, Args&&... args)
+            : joint_ptr(alloc)
+            {
+                create(additional_size.size, detail::forward<Args>(args)...);
+            }
+            /// @}
+
+            /// \effects Move-constructs the pointer.
+            /// Ownership will be transferred from `other` to the new object.
+            joint_ptr(joint_ptr&& other) noexcept
+            : allocator_reference<RawAllocator>(detail::move(other)), ptr_(other.ptr_)
+            {
+                other.ptr_ = nullptr;
+            }
+
+            /// \effects Destroys the object and deallocates its storage.
+            ~joint_ptr() noexcept
+            {
+                reset();
+            }
+
+            /// \effects Move-assings the pointer.
+            /// The previously owned object will be destroyed,
+            /// and ownership of `other` transferred.
+            joint_ptr& operator=(joint_ptr&& other) noexcept
+            {
+                joint_ptr tmp(detail::move(other));
+                swap(*this, tmp);
+                return *this;
+            }
+
+            /// \effects Same as `reset()`.
+            joint_ptr& operator=(std::nullptr_t) noexcept
+            {
+                reset();
+                return *this;
+            }
+
+            /// \effects Swaps to pointers and their ownership and allocator.
+            friend void swap(joint_ptr& a, joint_ptr& b) noexcept
+            {
+                detail::adl_swap(static_cast<allocator_reference<RawAllocator>&>(a),
+                                 static_cast<allocator_reference<RawAllocator>&>(b));
+                detail::adl_swap(a.ptr_, b.ptr_);
+            }
+
+            //=== modifiers ===//
+            /// \effects Destroys the object it refers to,
+            /// if there is any.
+            void reset() noexcept
+            {
+                if (ptr_)
+                {
+                    (**this).~element_type();
+                    this->deallocate_node(ptr_,
+                                          sizeof(element_type)
+                                              + detail::get_stack(*ptr_).capacity(
+                                                  detail::get_memory(*ptr_)),
+                                          alignof(element_type));
+                    ptr_ = nullptr;
+                }
+            }
+
+            //=== accessors ===//
+            /// \returns `true` if the pointer does own an object,
+            /// `false` otherwise.
+            explicit operator bool() const noexcept
+            {
+                return ptr_ != nullptr;
+            }
+
+            /// \returns A reference to the object it owns.
+            /// \requires The pointer must own an object,
+            /// i.e. `operator bool()` must return `true`.
+            element_type& operator*() const noexcept
+            {
+                WPI_MEMORY_ASSERT(ptr_);
+                return *get();
+            }
+
+            /// \returns A pointer to the object it owns.
+            /// \requires The pointer must own an object,
+            /// i.e. `operator bool()` must return `true`.
+            element_type* operator->() const noexcept
+            {
+                WPI_MEMORY_ASSERT(ptr_);
+                return get();
+            }
+
+            /// \returns A pointer to the object it owns
+            /// or `nullptr`, if it does not own any object.
+            element_type* get() const noexcept
+            {
+                return static_cast<element_type*>(ptr_);
+            }
+
+            /// \returns A reference to the allocator it will use for the deallocation.
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<allocator_reference<allocator_type>>().get_allocator())
+            {
+                return this->allocator_reference<allocator_type>::get_allocator();
+            }
+
+        private:
+            template <typename... Args>
+            void create(std::size_t additional_size, Args&&... args)
+            {
+                auto mem = this->allocate_node(sizeof(element_type) + additional_size,
+                                               alignof(element_type));
+
+                element_type* ptr = nullptr;
+#if WPI_HAS_EXCEPTION_SUPPORT
+                try
+                {
+                    ptr = ::new (mem)
+                        element_type(joint(additional_size), detail::forward<Args>(args)...);
+                }
+                catch (...)
+                {
+                    this->deallocate_node(mem, sizeof(element_type) + additional_size,
+                                          alignof(element_type));
+                    throw;
+                }
+#else
+                ptr = ::new (mem)
+                    element_type(joint(additional_size), detail::forward<Args>(args)...);
+#endif
+                ptr_ = ptr;
+            }
+
+            joint_type<T>* ptr_;
+
+            friend class joint_allocator;
+        };
+
+        /// @{
+        /// \returns `!ptr`,
+        /// i.e. if `ptr` does not own anything.
+        /// \relates joint_ptr
+        template <typename T, class RawAllocator>
+        bool operator==(const joint_ptr<T, RawAllocator>& ptr, std::nullptr_t)
+        {
+            return !ptr;
+        }
+
+        template <typename T, class RawAllocator>
+        bool operator==(std::nullptr_t, const joint_ptr<T, RawAllocator>& ptr)
+        {
+            return ptr == nullptr;
+        }
+        /// @}
+
+        /// @{
+        /// \returns `ptr.get() == p`,
+        /// i.e. if `ptr` ownws the object referred to by `p`.
+        /// \relates joint_ptr
+        template <typename T, class RawAllocator>
+        bool operator==(const joint_ptr<T, RawAllocator>& ptr, T* p)
+        {
+            return ptr.get() == p;
+        }
+
+        template <typename T, class RawAllocator>
+        bool operator==(T* p, const joint_ptr<T, RawAllocator>& ptr)
+        {
+            return ptr == p;
+        }
+        /// @}
+
+        /// @{
+        /// \returns `!(ptr == nullptr)`,
+        /// i.e. if `ptr` does own something.
+        /// \relates joint_ptr
+        template <typename T, class RawAllocator>
+        bool operator!=(const joint_ptr<T, RawAllocator>& ptr, std::nullptr_t)
+        {
+            return !(ptr == nullptr);
+        }
+
+        template <typename T, class RawAllocator>
+        bool operator!=(std::nullptr_t, const joint_ptr<T, RawAllocator>& ptr)
+        {
+            return ptr != nullptr;
+        }
+        /// @}
+
+        /// @{
+        /// \returns `!(ptr == p)`,
+        /// i.e. if `ptr` does not ownw the object referred to by `p`.
+        /// \relates joint_ptr
+        template <typename T, class RawAllocator>
+        bool operator!=(const joint_ptr<T, RawAllocator>& ptr, T* p)
+        {
+            return !(ptr == p);
+        }
+
+        template <typename T, class RawAllocator>
+        bool operator!=(T* p, const joint_ptr<T, RawAllocator>& ptr)
+        {
+            return ptr != p;
+        }
+        /// @}
+
+        /// @{
+        /// \returns A new \ref joint_ptr as if created with the same arguments passed to the constructor.
+        /// \relatesalso joint_ptr
+        /// \ingroup allocator
+        template <typename T, class RawAllocator, typename... Args>
+        auto allocate_joint(RawAllocator& alloc, joint_size additional_size, Args&&... args)
+            -> joint_ptr<T, RawAllocator>
+        {
+            return joint_ptr<T, RawAllocator>(alloc, additional_size,
+                                              detail::forward<Args>(args)...);
+        }
+
+        template <typename T, class RawAllocator, typename... Args>
+        auto allocate_joint(const RawAllocator& alloc, joint_size additional_size, Args&&... args)
+            -> joint_ptr<T, RawAllocator>
+        {
+            return joint_ptr<T, RawAllocator>(alloc, additional_size,
+                                              detail::forward<Args>(args)...);
+        }
+        /// @}
+
+        /// @{
+        /// \returns A new \ref joint_ptr that points to a copy of `joint`.
+        /// It will allocate as much memory as needed and forward to the copy constructor.
+        /// \ingroup allocator
+        template <class RawAllocator, typename T>
+        auto clone_joint(RawAllocator& alloc, const joint_type<T>& joint)
+            -> joint_ptr<T, RawAllocator>
+        {
+            return joint_ptr<T, RawAllocator>(alloc,
+                                              joint_size(detail::get_stack(joint).capacity_used(
+                                                  detail::get_memory(joint))),
+                                              static_cast<const T&>(joint));
+        }
+
+        template <class RawAllocator, typename T>
+        auto clone_joint(const RawAllocator& alloc, const joint_type<T>& joint)
+            -> joint_ptr<T, RawAllocator>
+        {
+            return joint_ptr<T, RawAllocator>(alloc,
+                                              joint_size(detail::get_stack(joint).capacity_used(
+                                                  detail::get_memory(joint))),
+                                              static_cast<const T&>(joint));
+        }
+        /// @}
+
+        /// A \concept{concept_rawallocator,RawAllocator} that uses the additional joint memory for its allocation.
+        ///
+        /// It is somewhat limited and allows only allocation once.
+        /// All joint allocators for an object share the joint memory and must not be used in multiple threads.
+        /// The memory it returns is owned by a \ref joint_ptr and will be destroyed through it.
+        /// \ingroup allocator
+        class joint_allocator
+        {
+        public:
+#if defined(__GNUC__) && (!defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0)
+            // std::string requires default constructor for the small string optimization when using gcc's old ABI
+            // so add one, but it must never be used for allocation
+            joint_allocator() noexcept : stack_(nullptr) {}
+#endif
+
+            /// \effects Creates it using the joint memory of the given object.
+            template <typename T>
+            joint_allocator(joint_type<T>& j) noexcept : stack_(&detail::get_stack(j))
+            {
+            }
+
+            joint_allocator(const joint_allocator& other) noexcept = default;
+            joint_allocator& operator=(const joint_allocator& other) noexcept = default;
+
+            /// \effects Allocates a node with given properties.
+            /// \returns A pointer to the new node.
+            /// \throws \ref out_of_fixed_memory exception if this function has been called for a second time
+            /// or the joint memory block is exhausted.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                WPI_MEMORY_ASSERT(stack_);
+                auto mem = stack_->allocate(size, alignment);
+                if (!mem)
+                    WPI_THROW(out_of_fixed_memory(info(), size));
+                return mem;
+            }
+
+            /// \effects Deallocates the node, if possible.
+            /// \note It is only possible if it was the last allocation.
+            void deallocate_node(void* ptr, std::size_t size, std::size_t) noexcept
+            {
+                WPI_MEMORY_ASSERT(stack_);
+                auto end = static_cast<char*>(ptr) + size;
+                if (end == stack_->top())
+                    stack_->unwind(ptr);
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return allocator_info(WPI_MEMORY_LOG_PREFIX "::joint_allocator", this);
+            }
+
+            detail::joint_stack* stack_;
+
+            friend bool operator==(const joint_allocator& lhs, const joint_allocator& rhs) noexcept;
+        };
+
+        /// @{
+        /// \returns Whether `lhs` and `rhs` use the same joint memory for the allocation.
+        /// \relates joint_allocator
+        inline bool operator==(const joint_allocator& lhs, const joint_allocator& rhs) noexcept
+        {
+            return lhs.stack_ == rhs.stack_;
+        }
+
+        inline bool operator!=(const joint_allocator& lhs, const joint_allocator& rhs) noexcept
+        {
+            return !(lhs == rhs);
+        }
+        /// @}
+
+        /// Specialization of \ref is_shared_allocator to mark \ref joint_allocator as shared.
+        /// This allows using it as \ref allocator_reference directly.
+        /// \ingroup allocator
+        template <>
+        struct is_shared_allocator<joint_allocator> : std::true_type
+        {
+        };
+
+        /// Specialization of \ref is_thread_safe_allocator to mark \ref joint_allocator as thread safe.
+        /// This is an optimization to get rid of the mutex in \ref allocator_storage,
+        /// as joint allocator must not be shared between threads.
+        /// \note The allocator is *not* thread safe, it just must not be shared.
+        template <>
+        struct is_thread_safe_allocator<joint_allocator> : std::true_type
+        {
+        };
+
+#if !defined(DOXYGEN)
+        template <class RawAllocator>
+        struct propagation_traits;
+#endif
+
+        /// Specialization of the \ref propagation_traits for the \ref joint_allocator.
+        /// A joint allocator does not propagate on assignment
+        /// and it is not allowed to use the regular copy/move constructor of allocator aware containers,
+        /// instead it needs the copy/move constructor with allocator.
+        /// \note This is required because the container constructor will end up copying/moving the allocator.
+        /// But this is not allowed as you need the allocator with the correct joined memory.
+        /// Copying can be customized (i.e. forbidden), but sadly not move, so keep that in mind.
+        /// \ingroup allocator
+        template <>
+        struct propagation_traits<joint_allocator>
+        {
+            using propagate_on_container_swap            = std::false_type;
+            using propagate_on_container_move_assignment = std::false_type;
+            using propagate_on_container_copy_assignment = std::false_type;
+
+            template <class AllocReference>
+            static AllocReference select_on_container_copy_construction(const AllocReference&)
+            {
+                static_assert(always_false<AllocReference>::value,
+                              "you must not use the regular copy constructor");
+            }
+
+        private:
+            template <typename T>
+            struct always_false : std::false_type
+            {
+            };
+        };
+
+        /// A zero overhead dynamic array using joint memory.
+        ///
+        /// If you use, e.g. `std::vector` with \ref joint_allocator,
+        /// this has a slight additional overhead.
+        /// This type is joint memory aware and has no overhead.
+        ///
+        /// It has a dynamic, but fixed size,
+        /// it cannot grow after it has been created.
+        /// \ingroup allocator
+        template <typename T>
+        class joint_array
+        {
+        public:
+            using value_type     = T;
+            using iterator       = value_type*;
+            using const_iterator = const value_type*;
+
+            //=== constructors ===//
+            /// \effects Creates with `size` default-constructed objects using the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if `size` is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename JointType>
+            joint_array(std::size_t size, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), size)
+            {
+            }
+
+            /// \effects Creates with `size` copies of `val`  using the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if `size` is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename JointType>
+            joint_array(std::size_t size, const value_type& val, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), size, val)
+            {
+            }
+
+            /// \effects Creates with the copies of the objects in the initializer list using the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if the size is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename JointType>
+            joint_array(std::initializer_list<value_type> ilist, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), ilist)
+            {
+            }
+
+            /// \effects Creates it by forwarding each element of the range to `T`s constructor  using the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if the size is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename InIter, typename JointType,
+                      typename = decltype(*std::declval<InIter&>()++)>
+            joint_array(InIter begin, InIter end, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), begin, end)
+            {
+            }
+
+            joint_array(const joint_array&) = delete;
+
+            /// \effects Copy constructs each element from `other` into the storage of the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if the size is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename JointType>
+            joint_array(const joint_array& other, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), other)
+            {
+            }
+
+            joint_array(joint_array&&) = delete;
+
+            /// \effects Move constructs each element from `other` into the storage of the specified joint memory.
+            /// \throws \ref out_of_fixed_memory if the size is too big
+            /// and anything thrown by `T`s constructor.
+            /// If an allocation is thrown, the memory will be released directly.
+            template <typename JointType>
+            joint_array(joint_array&& other, joint_type<JointType>& j)
+            : joint_array(detail::get_stack(j), detail::move(other))
+            {
+            }
+
+            /// \effects Destroys all objects,
+            /// but does not release the storage.
+            ~joint_array() noexcept
+            {
+                for (std::size_t i = 0u; i != size_; ++i)
+                    ptr_[i].~T();
+            }
+
+            joint_array& operator=(const joint_array&) = delete;
+            joint_array& operator=(joint_array&&) = delete;
+
+            //=== accessors ===//
+            /// @{
+            /// \returns A reference to the `i`th object.
+            /// \requires `i < size()`.
+            value_type& operator[](std::size_t i) noexcept
+            {
+                WPI_MEMORY_ASSERT(i < size_);
+                return ptr_[i];
+            }
+
+            const value_type& operator[](std::size_t i) const noexcept
+            {
+                WPI_MEMORY_ASSERT(i < size_);
+                return ptr_[i];
+            }
+            /// @}
+
+            /// @{
+            /// \returns A pointer to the first object.
+            /// It points to contiguous memory and can be used to access the objects directly.
+            value_type* data() noexcept
+            {
+                return ptr_;
+            }
+
+            const value_type* data() const noexcept
+            {
+                return ptr_;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A random access iterator to the first element.
+            iterator begin() noexcept
+            {
+                return ptr_;
+            }
+
+            const_iterator begin() const noexcept
+            {
+                return ptr_;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A random access iterator one past the last element.
+            iterator end() noexcept
+            {
+                return ptr_ + size_;
+            }
+
+            const_iterator end() const noexcept
+            {
+                return ptr_ + size_;
+            }
+            /// @}
+
+            /// \returns The number of elements in the array.
+            std::size_t size() const noexcept
+            {
+                return size_;
+            }
+
+            /// \returns `true` if the array is empty, `false` otherwise.
+            bool empty() const noexcept
+            {
+                return size_ == 0u;
+            }
+
+        private:
+            // allocate only
+            struct allocate_only
+            {
+            };
+            joint_array(allocate_only, detail::joint_stack& stack, std::size_t size)
+            : ptr_(nullptr), size_(0u)
+            {
+                ptr_ = static_cast<T*>(stack.allocate(size * sizeof(T), alignof(T)));
+                if (!ptr_)
+                    WPI_THROW(out_of_fixed_memory(info(), size * sizeof(T)));
+            }
+
+            class builder
+            {
+            public:
+                builder(detail::joint_stack& stack, T* ptr) noexcept
+                : stack_(&stack), objects_(ptr), size_(0u)
+                {
+                }
+
+                ~builder() noexcept
+                {
+                    for (std::size_t i = 0u; i != size_; ++i)
+                        objects_[i].~T();
+
+                    if (size_)
+                        stack_->unwind(objects_);
+                }
+
+                builder(builder&&) = delete;
+                builder& operator=(builder&&) = delete;
+
+                template <typename... Args>
+                T* create(Args&&... args)
+                {
+                    auto ptr = ::new (static_cast<void*>(&objects_[size_]))
+                        T(detail::forward<Args>(args)...);
+                    ++size_;
+                    return ptr;
+                }
+
+                std::size_t size() const noexcept
+                {
+                    return size_;
+                }
+
+                std::size_t release() noexcept
+                {
+                    auto res = size_;
+                    size_    = 0u;
+                    return res;
+                }
+
+            private:
+                detail::joint_stack* stack_;
+                T*                   objects_;
+                std::size_t          size_;
+            };
+
+            joint_array(detail::joint_stack& stack, std::size_t size)
+            : joint_array(allocate_only{}, stack, size)
+            {
+                builder b(stack, ptr_);
+                for (auto i = 0u; i != size; ++i)
+                    b.create();
+                size_ = b.release();
+            }
+
+            joint_array(detail::joint_stack& stack, std::size_t size, const value_type& value)
+            : joint_array(allocate_only{}, stack, size)
+            {
+                builder b(stack, ptr_);
+                for (auto i = 0u; i != size; ++i)
+                    b.create(value);
+                size_ = b.release();
+            }
+
+            joint_array(detail::joint_stack& stack, std::initializer_list<value_type> ilist)
+            : joint_array(allocate_only{}, stack, ilist.size())
+            {
+                builder b(stack, ptr_);
+                for (auto& elem : ilist)
+                    b.create(elem);
+                size_ = b.release();
+            }
+
+            joint_array(detail::joint_stack& stack, const joint_array& other)
+            : joint_array(allocate_only{}, stack, other.size())
+            {
+                builder b(stack, ptr_);
+                for (auto& elem : other)
+                    b.create(elem);
+                size_ = b.release();
+            }
+
+            joint_array(detail::joint_stack& stack, joint_array&& other)
+            : joint_array(allocate_only{}, stack, other.size())
+            {
+                builder b(stack, ptr_);
+                for (auto& elem : other)
+                    b.create(detail::move(elem));
+                size_ = b.release();
+            }
+
+            template <typename InIter>
+            joint_array(detail::joint_stack& stack, InIter begin, InIter end)
+            : ptr_(nullptr), size_(0u)
+            {
+                if (begin == end)
+                    return;
+
+                ptr_ = static_cast<T*>(stack.allocate(sizeof(T), alignof(T)));
+                if (!ptr_)
+                    WPI_THROW(out_of_fixed_memory(info(), sizeof(T)));
+
+                builder b(stack, ptr_);
+                b.create(*begin++);
+
+                for (auto last = ptr_; begin != end; ++begin)
+                {
+                    // just bump stack to get more memory
+                    if (!stack.bump(sizeof(T)))
+                        WPI_THROW(out_of_fixed_memory(info(), b.size() * sizeof(T)));
+
+                    auto cur = b.create(*begin);
+                    WPI_MEMORY_ASSERT(last + 1 == cur);
+                    last = cur;
+                }
+
+                size_ = b.release();
+            }
+
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::joint_array", this};
+            }
+
+            value_type* ptr_;
+            std::size_t size_;
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_JOINT_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/malloc_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/malloc_allocator.hpp
new file mode 100644
index 0000000..3be9820
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/malloc_allocator.hpp
@@ -0,0 +1,71 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MALLOC_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_MALLOC_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::malloc_allocator.
+/// \note Only available on a hosted implementation.
+
+#include "config.hpp"
+#if !WPI_HOSTED_IMPLEMENTATION
+#error "This header is only available for a hosted implementation."
+#endif
+
+#include <cstdlib>
+#include <memory>
+
+#include "detail/lowlevel_allocator.hpp"
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+#include "allocator_traits.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        struct allocator_info;
+
+        namespace detail
+        {
+            struct malloc_allocator_impl
+            {
+                static allocator_info info() noexcept;
+
+                static void* allocate(std::size_t size, std::size_t) noexcept
+                {
+                    return std::malloc(size);
+                }
+
+                static void deallocate(void* ptr, std::size_t, std::size_t) noexcept
+                {
+                    std::free(ptr);
+                }
+
+                static std::size_t max_node_size() noexcept
+                {
+                    return std::allocator_traits<std::allocator<char>>::max_size({});
+                }
+            };
+
+            WPI_MEMORY_LL_ALLOCATOR_LEAK_CHECKER(malloc_allocator_impl,
+                                                       malloc_alloator_leak_checker)
+        } // namespace detail
+
+        /// A stateless \concept{concept_rawallocator,RawAllocator} that allocates memory using <tt>std::malloc()</tt>.
+        /// It throws \ref out_of_memory when the allocation fails.
+        /// \ingroup allocator
+        using malloc_allocator =
+            WPI_IMPL_DEFINED(detail::lowlevel_allocator<detail::malloc_allocator_impl>);
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class detail::lowlevel_allocator<detail::malloc_allocator_impl>;
+        extern template class allocator_traits<malloc_allocator>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_MALLOC_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_arena.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_arena.hpp
new file mode 100644
index 0000000..a634993
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_arena.hpp
@@ -0,0 +1,693 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_ARENA_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_ARENA_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::memory_arena and related functionality regarding \concept{concept_blockallocator,BlockAllocators}.
+
+#include <type_traits>
+
+#include "detail/debug_helpers.hpp"
+#include "detail/assert.hpp"
+#include "detail/utility.hpp"
+#include "allocator_traits.hpp"
+#include "config.hpp"
+#include "default_allocator.hpp"
+#include "error.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A memory block.
+        /// It is defined by its starting address and size.
+        /// \ingroup core
+        struct memory_block
+        {
+            void*       memory; ///< The address of the memory block (might be \c nullptr).
+            std::size_t size;   ///< The size of the memory block (might be \c 0).
+
+            /// \effects Creates an invalid memory block with starting address \c nullptr and size \c 0.
+            memory_block() noexcept : memory_block(nullptr, std::size_t(0)) {}
+
+            /// \effects Creates a memory block from a given starting address and size.
+            memory_block(void* mem, std::size_t s) noexcept : memory(mem), size(s) {}
+
+            /// \effects Creates a memory block from a [begin,end) range.
+            memory_block(void* begin, void* end) noexcept
+            : memory_block(begin, static_cast<std::size_t>(static_cast<char*>(end)
+                                                           - static_cast<char*>(begin)))
+            {
+            }
+
+            /// \returns Whether or not a pointer is inside the memory.
+            bool contains(const void* address) const noexcept
+            {
+                auto mem  = static_cast<const char*>(memory);
+                auto addr = static_cast<const char*>(address);
+                return addr >= mem && addr < mem + size;
+            }
+        };
+
+        namespace detail
+        {
+            template <class BlockAllocator>
+            std::true_type is_block_allocator_impl(
+                int,
+                WPI_SFINAE(std::declval<memory_block&>() =
+                                     std::declval<BlockAllocator&>().allocate_block()),
+                WPI_SFINAE(std::declval<std::size_t&>() =
+                                     std::declval<BlockAllocator&>().next_block_size()),
+                WPI_SFINAE(std::declval<BlockAllocator>().deallocate_block(memory_block{})));
+
+            template <typename T>
+            std::false_type is_block_allocator_impl(short);
+        } // namespace detail
+
+        /// Traits that check whether a type models concept \concept{concept_blockallocator,BlockAllocator}.
+        /// \ingroup core
+        template <typename T>
+        struct is_block_allocator : decltype(detail::is_block_allocator_impl<T>(0))
+        {
+        };
+
+#if !defined(DOXYGEN)
+        template <class BlockAllocator, bool Cached = true>
+        class memory_arena;
+#endif
+
+        /// @{
+        /// Controls the caching of \ref memory_arena.
+        /// By default, deallocated blocks are put onto a cache, so they can be reused later;
+        /// this tag value enable/disable it..<br>
+        /// This can be useful, e.g. if there will never be blocks available for deallocation.
+        /// The (tiny) overhead for the cache can then be disabled.
+        /// An example is \ref memory_pool.
+        /// \ingroup core
+        constexpr bool cached_arena   = true;
+        constexpr bool uncached_arena = false;
+        /// @}
+
+        namespace detail
+        {
+            // stores memory block in an intrusive linked list and allows LIFO access
+            class memory_block_stack
+            {
+            public:
+                memory_block_stack() noexcept : head_(nullptr) {}
+
+                ~memory_block_stack() noexcept {}
+
+                memory_block_stack(memory_block_stack&& other) noexcept : head_(other.head_)
+                {
+                    other.head_ = nullptr;
+                }
+
+                memory_block_stack& operator=(memory_block_stack&& other) noexcept
+                {
+                    memory_block_stack tmp(detail::move(other));
+                    swap(*this, tmp);
+                    return *this;
+                }
+
+                friend void swap(memory_block_stack& a, memory_block_stack& b) noexcept
+                {
+                    detail::adl_swap(a.head_, b.head_);
+                }
+
+                // the raw allocated block returned from an allocator
+                using allocated_mb = memory_block;
+
+                // the inserted block slightly smaller to allow for the fixup value
+                using inserted_mb = memory_block;
+
+                // how much an inserted block is smaller
+                static constexpr std::size_t implementation_offset() noexcept
+                {
+                    // node size rounded up to the next multiple of max_alignment.
+                    return (sizeof(node) / max_alignment + (sizeof(node) % max_alignment != 0))
+                           * max_alignment;
+                }
+
+                // pushes a memory block
+                void push(allocated_mb block) noexcept;
+
+                // pops a memory block and returns the original block
+                allocated_mb pop() noexcept;
+
+                // steals the top block from another stack
+                void steal_top(memory_block_stack& other) noexcept;
+
+                // returns the last pushed() inserted memory block
+                inserted_mb top() const noexcept
+                {
+                    WPI_MEMORY_ASSERT(head_);
+                    auto mem = static_cast<void*>(head_);
+                    return {static_cast<char*>(mem) + implementation_offset(), head_->usable_size};
+                }
+
+                bool empty() const noexcept
+                {
+                    return head_ == nullptr;
+                }
+
+                bool owns(const void* ptr) const noexcept;
+
+                // O(n) size
+                std::size_t size() const noexcept;
+
+            private:
+                struct node
+                {
+                    node*       prev;
+                    std::size_t usable_size;
+
+                    node(node* p, std::size_t size) noexcept : prev(p), usable_size(size) {}
+                };
+
+                node* head_;
+            };
+
+            template <bool Cached>
+            class memory_arena_cache;
+
+            template <>
+            class memory_arena_cache<cached_arena>
+            {
+            protected:
+                bool cache_empty() const noexcept
+                {
+                    return cached_.empty();
+                }
+
+                std::size_t cache_size() const noexcept
+                {
+                    return cached_.size();
+                }
+
+                std::size_t cached_block_size() const noexcept
+                {
+                    return cached_.top().size;
+                }
+
+                bool take_from_cache(detail::memory_block_stack& used) noexcept
+                {
+                    if (cached_.empty())
+                        return false;
+                    used.steal_top(cached_);
+                    return true;
+                }
+
+                template <class BlockAllocator>
+                void do_deallocate_block(BlockAllocator&, detail::memory_block_stack& used) noexcept
+                {
+                    cached_.steal_top(used);
+                }
+
+                template <class BlockAllocator>
+                void do_shrink_to_fit(BlockAllocator& alloc) noexcept
+                {
+                    detail::memory_block_stack to_dealloc;
+                    // pop from cache and push to temporary stack
+                    // this revers order
+                    while (!cached_.empty())
+                        to_dealloc.steal_top(cached_);
+                    // now dealloc everything
+                    while (!to_dealloc.empty())
+                        alloc.deallocate_block(to_dealloc.pop());
+                }
+
+            private:
+                detail::memory_block_stack cached_;
+            };
+
+            template <>
+            class memory_arena_cache<uncached_arena>
+            {
+            protected:
+                bool cache_empty() const noexcept
+                {
+                    return true;
+                }
+
+                std::size_t cache_size() const noexcept
+                {
+                    return 0u;
+                }
+
+                std::size_t cached_block_size() const noexcept
+                {
+                    return 0u;
+                }
+
+                bool take_from_cache(detail::memory_block_stack&) noexcept
+                {
+                    return false;
+                }
+
+                template <class BlockAllocator>
+                void do_deallocate_block(BlockAllocator&             alloc,
+                                         detail::memory_block_stack& used) noexcept
+                {
+                    alloc.deallocate_block(used.pop());
+                }
+
+                template <class BlockAllocator>
+                void do_shrink_to_fit(BlockAllocator&) noexcept
+                {
+                }
+            };
+        } // namespace detail
+
+        /// A memory arena that manages huge memory blocks for a higher-level allocator.
+        /// Some allocators like \ref memory_stack work on huge memory blocks,
+        /// this class manages them fro those allocators.
+        /// It uses a \concept{concept_blockallocator,BlockAllocator} for the allocation of those blocks.
+        /// The memory blocks in use are put onto a stack like structure, deallocation will pop from the top,
+        /// so it is only possible to deallocate the last allocated block of the arena.
+        /// By default, blocks are not really deallocated but stored in a cache.
+        /// This can be disabled with the second template parameter,
+        /// passing it \ref uncached_arena (or \c false) disables it,
+        /// \ref cached_arena (or \c true) enables it explicitly.
+        /// \ingroup core
+        template <class BlockAllocator, bool Cached /* = true */>
+        class memory_arena : WPI_EBO(BlockAllocator),
+                             WPI_EBO(detail::memory_arena_cache<Cached>)
+        {
+            static_assert(is_block_allocator<BlockAllocator>::value,
+                          "BlockAllocator is not a BlockAllocator!");
+            using cache = detail::memory_arena_cache<Cached>;
+
+        public:
+            using allocator_type = BlockAllocator;
+            using is_cached      = std::integral_constant<bool, Cached>;
+
+            /// \returns The minimum block size required for an arena containing the given amount of memory.
+            /// If an arena is created with the result of `min_block_size(n)`, the resulting capacity will be exactly `n`.
+            /// \requires `byte_size` must be a positive number.
+            static constexpr std::size_t min_block_size(std::size_t byte_size) noexcept
+            {
+                return detail::memory_block_stack::implementation_offset() + byte_size;
+            }
+
+            /// \effects Creates it by giving it the size and other arguments for the \concept{concept_blockallocator,BlockAllocator}.
+            /// It forwards these arguments to its constructor.
+            /// \requires \c block_size must be greater than \c min_block_size(0) and other requirements depending on the \concept{concept_blockallocator,BlockAllocator}.
+            /// \throws Anything thrown by the constructor of the \c BlockAllocator.
+            template <typename... Args>
+            explicit memory_arena(std::size_t block_size, Args&&... args)
+            : allocator_type(block_size, detail::forward<Args>(args)...)
+            {
+                WPI_MEMORY_ASSERT(block_size > min_block_size(0));
+            }
+
+            /// \effects Deallocates all memory blocks that where requested back to the \concept{concept_blockallocator,BlockAllocator}.
+            ~memory_arena() noexcept
+            {
+                // clear cache
+                shrink_to_fit();
+                // now deallocate everything
+                while (!used_.empty())
+                    allocator_type::deallocate_block(used_.pop());
+            }
+
+            /// @{
+            /// \effects Moves the arena.
+            /// The new arena takes ownership over all the memory blocks from the other arena object,
+            /// which is empty after that.
+            /// This does not invalidate any memory blocks.
+            memory_arena(memory_arena&& other) noexcept
+            : allocator_type(detail::move(other)),
+              cache(detail::move(other)),
+              used_(detail::move(other.used_))
+            {
+            }
+
+            memory_arena& operator=(memory_arena&& other) noexcept
+            {
+                memory_arena tmp(detail::move(other));
+                swap(*this, tmp);
+                return *this;
+            }
+            /// @}
+
+            /// \effects Swaps to memory arena objects.
+            /// This does not invalidate any memory blocks.
+            friend void swap(memory_arena& a, memory_arena& b) noexcept
+            {
+                detail::adl_swap(static_cast<allocator_type&>(a), static_cast<allocator_type&>(b));
+                detail::adl_swap(static_cast<cache&>(a), static_cast<cache&>(b));
+                detail::adl_swap(a.used_, b.used_);
+            }
+
+            /// \effects Allocates a new memory block.
+            /// It first uses a cache of previously deallocated blocks, if caching is enabled,
+            /// if it is empty, allocates a new one.
+            /// \returns The new \ref memory_block.
+            /// \throws Anything thrown by the \concept{concept_blockallocator,BlockAllocator} allocation function.
+            memory_block allocate_block()
+            {
+                if (!this->take_from_cache(used_))
+                    used_.push(allocator_type::allocate_block());
+
+                auto block = used_.top();
+                detail::debug_fill_internal(block.memory, block.size, false);
+                return block;
+            }
+
+            /// \returns The current memory block.
+            /// This is the memory block that will be deallocated by the next call to \ref deallocate_block().
+            memory_block current_block() const noexcept
+            {
+                return used_.top();
+            }
+
+            /// \effects Deallocates the current memory block.
+            /// The current memory block is the block on top of the stack of blocks.
+            /// If caching is enabled, it does not really deallocate it but puts it onto a cache for later use,
+            /// use \ref shrink_to_fit() to purge that cache.
+            void deallocate_block() noexcept
+            {
+                auto block = used_.top();
+                detail::debug_fill_internal(block.memory, block.size, true);
+                this->do_deallocate_block(get_allocator(), used_);
+            }
+
+            /// \returns If `ptr` is in memory owned by the arena.
+            bool owns(const void* ptr) const noexcept
+            {
+                return used_.owns(ptr);
+            }
+
+            /// \effects Purges the cache of unused memory blocks by returning them.
+            /// The memory blocks will be deallocated in reversed order of allocation.
+            /// Does nothing if caching is disabled.
+            void shrink_to_fit() noexcept
+            {
+                this->do_shrink_to_fit(get_allocator());
+            }
+
+            /// \returns The capacity of the arena, i.e. how many blocks are used and cached.
+            std::size_t capacity() const noexcept
+            {
+                return size() + cache_size();
+            }
+
+            /// \returns The size of the cache, i.e. how many blocks can be allocated without allocation.
+            std::size_t cache_size() const noexcept
+            {
+                return cache::cache_size();
+            }
+
+            /// \returns The size of the arena, i.e. how many blocks are in use.
+            /// It is always smaller or equal to the \ref capacity().
+            std::size_t size() const noexcept
+            {
+                return used_.size();
+            }
+
+            /// \returns The size of the next memory block,
+            /// i.e. of the next call to \ref allocate_block().
+            /// If there are blocks in the cache, returns size of the next one.
+            /// Otherwise forwards to the \concept{concept_blockallocator,BlockAllocator} and subtracts an implementation offset.
+            std::size_t next_block_size() const noexcept
+            {
+                return this->cache_empty() ?
+                           allocator_type::next_block_size()
+                               - detail::memory_block_stack::implementation_offset() :
+                           this->cached_block_size();
+            }
+
+            /// \returns A reference of the \concept{concept_blockallocator,BlockAllocator} object.
+            /// \requires It is undefined behavior to move this allocator out into another object.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+        private:
+            detail::memory_block_stack used_;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class memory_arena<static_block_allocator, true>;
+        extern template class memory_arena<static_block_allocator, false>;
+        extern template class memory_arena<virtual_block_allocator, true>;
+        extern template class memory_arena<virtual_block_allocator, false>;
+#endif
+
+        /// A \concept{concept_blockallocator,BlockAllocator} that uses a given \concept{concept_rawallocator,RawAllocator} for allocating the blocks.
+        /// It calls the \c allocate_array() function with a node of size \c 1 and maximum alignment on the used allocator for the block allocation.
+        /// The size of the next memory block will grow by a given factor after each allocation,
+        /// allowing an amortized constant allocation time in the higher level allocator.
+        /// The factor can be given as rational in the template parameter, default is \c 2.
+        /// \ingroup adapter
+        template <class RawAllocator = default_allocator, unsigned Num = 2, unsigned Den = 1>
+        class growing_block_allocator
+        : WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+            static_assert(float(Num) / Den >= 1.0, "invalid growth factor");
+
+            using traits = allocator_traits<RawAllocator>;
+
+        public:
+            using allocator_type = typename traits::allocator_type;
+
+            /// \effects Creates it by giving it the initial block size, the allocator object and the growth factor.
+            /// By default, it uses a default-constructed allocator object and a growth factor of \c 2.
+            /// \requires \c block_size must be greater than 0.
+            explicit growing_block_allocator(std::size_t    block_size,
+                                             allocator_type alloc = allocator_type()) noexcept
+            : allocator_type(detail::move(alloc)), block_size_(block_size)
+            {
+            }
+
+            /// \effects Allocates a new memory block and increases the block size for the next allocation.
+            /// \returns The new \ref memory_block.
+            /// \throws Anything thrown by the \c allocate_array() function of the \concept{concept_rawallocator,RawAllocator}.
+            memory_block allocate_block()
+            {
+                auto memory =
+                    traits::allocate_array(get_allocator(), block_size_, 1, detail::max_alignment);
+                memory_block block(memory, block_size_);
+                block_size_ = grow_block_size(block_size_);
+                return block;
+            }
+
+            /// \effects Deallocates a previously allocated memory block.
+            /// This does not decrease the block size.
+            /// \requires \c block must be previously returned by a call to \ref allocate_block().
+            void deallocate_block(memory_block block) noexcept
+            {
+                traits::deallocate_array(get_allocator(), block.memory, block.size, 1,
+                                         detail::max_alignment);
+            }
+
+            /// \returns The size of the memory block returned by the next call to \ref allocate_block().
+            std::size_t next_block_size() const noexcept
+            {
+                return block_size_;
+            }
+
+            /// \returns A reference to the used \concept{concept_rawallocator,RawAllocator} object.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            /// \returns The growth factor.
+            static float growth_factor() noexcept
+            {
+                static constexpr auto factor = float(Num) / Den;
+                return factor;
+            }
+
+            static std::size_t grow_block_size(std::size_t block_size) noexcept
+            {
+                return block_size * Num / Den;
+            }
+
+        private:
+            std::size_t block_size_;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class growing_block_allocator<>;
+        extern template class memory_arena<growing_block_allocator<>, true>;
+        extern template class memory_arena<growing_block_allocator<>, false>;
+#endif
+
+        /// A \concept{concept_blockallocator,BlockAllocator} that allows only one block allocation.
+        /// It can be used to prevent higher-level allocators from expanding.
+        /// The one block allocation is performed through the \c allocate_array() function of the given \concept{concept_rawallocator,RawAllocator}.
+        /// \ingroup adapter
+        template <class RawAllocator = default_allocator>
+        class fixed_block_allocator : WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+            using traits = allocator_traits<RawAllocator>;
+
+        public:
+            using allocator_type = typename traits::allocator_type;
+
+            /// \effects Creates it by passing it the size of the block and the allocator object.
+            /// \requires \c block_size must be greater than 0,
+            explicit fixed_block_allocator(std::size_t    block_size,
+                                           allocator_type alloc = allocator_type()) noexcept
+            : allocator_type(detail::move(alloc)), block_size_(block_size)
+            {
+            }
+
+            /// \effects Allocates a new memory block or throws an exception if there was already one allocation.
+            /// \returns The new \ref memory_block.
+            /// \throws Anything thrown by the \c allocate_array() function of the \concept{concept_rawallocator,RawAllocator} or \ref out_of_memory if this is not the first call.
+            memory_block allocate_block()
+            {
+                if (block_size_)
+                {
+                    auto         mem = traits::allocate_array(get_allocator(), block_size_, 1,
+                                                      detail::max_alignment);
+                    memory_block block(mem, block_size_);
+                    block_size_ = 0u;
+                    return block;
+                }
+                WPI_THROW(out_of_fixed_memory(info(), block_size_));
+            }
+
+            /// \effects Deallocates the previously allocated memory block.
+            /// It also resets and allows a new call again.
+            void deallocate_block(memory_block block) noexcept
+            {
+                detail::debug_check_pointer([&] { return block_size_ == 0u; }, info(),
+                                            block.memory);
+                traits::deallocate_array(get_allocator(), block.memory, block.size, 1,
+                                         detail::max_alignment);
+                block_size_ = block.size;
+            }
+
+            /// \returns The size of the next block which is either the initial size or \c 0.
+            std::size_t next_block_size() const noexcept
+            {
+                return block_size_;
+            }
+
+            /// \returns A reference to the used \concept{concept_rawallocator,RawAllocator} object.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+        private:
+            allocator_info info() noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::fixed_block_allocator", this};
+            }
+
+            std::size_t block_size_;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class fixed_block_allocator<>;
+        extern template class memory_arena<fixed_block_allocator<>, true>;
+        extern template class memory_arena<fixed_block_allocator<>, false>;
+#endif
+
+        namespace detail
+        {
+            template <class RawAlloc>
+            using default_block_wrapper = growing_block_allocator<RawAlloc>;
+
+            template <template <class...> class Wrapper, class BlockAllocator, typename... Args>
+            BlockAllocator make_block_allocator(std::true_type, std::size_t block_size,
+                                                Args&&... args)
+            {
+                return BlockAllocator(block_size, detail::forward<Args>(args)...);
+            }
+
+            template <template <class...> class Wrapper, class RawAlloc>
+            auto make_block_allocator(std::false_type, std::size_t block_size,
+                                      RawAlloc alloc = RawAlloc()) -> Wrapper<RawAlloc>
+            {
+                return Wrapper<RawAlloc>(block_size, detail::move(alloc));
+            }
+        } // namespace detail
+
+        /// Takes either a \concept{concept_blockallocator,BlockAllocator} or a \concept{concept_rawallocator,RawAllocator}.
+        /// In the first case simply aliases the type unchanged, in the second to \ref growing_block_allocator (or the template in `BlockAllocator`) with the \concept{concept_rawallocator,RawAllocator}.
+        /// Using this allows passing normal \concept{concept_rawallocator,RawAllocators} as \concept{concept_blockallocator,BlockAllocators}.
+        /// \ingroup core
+        template <class BlockOrRawAllocator,
+                  template <typename...> class BlockAllocator = detail::default_block_wrapper>
+        using make_block_allocator_t = WPI_IMPL_DEFINED(
+            typename std::conditional<is_block_allocator<BlockOrRawAllocator>::value,
+                                      BlockOrRawAllocator,
+                                      BlockAllocator<BlockOrRawAllocator>>::type);
+
+        /// @{
+        /// Helper function make a \concept{concept_blockallocator,BlockAllocator}.
+        /// \returns A \concept{concept_blockallocator,BlockAllocator} of the given type created with the given arguments.
+        /// \requires Same requirements as the constructor.
+        /// \ingroup core
+        template <class BlockOrRawAllocator, typename... Args>
+        make_block_allocator_t<BlockOrRawAllocator> make_block_allocator(std::size_t block_size,
+                                                                         Args&&... args)
+        {
+            return detail::make_block_allocator<
+                detail::default_block_wrapper,
+                BlockOrRawAllocator>(is_block_allocator<BlockOrRawAllocator>{}, block_size,
+                                     detail::forward<Args>(args)...);
+        }
+
+        template <template <class...> class BlockAllocator, class BlockOrRawAllocator,
+                  typename... Args>
+        make_block_allocator_t<BlockOrRawAllocator, BlockAllocator> make_block_allocator(
+            std::size_t block_size, Args&&... args)
+        {
+            return detail::make_block_allocator<
+                BlockAllocator, BlockOrRawAllocator>(is_block_allocator<BlockOrRawAllocator>{},
+                                                     block_size, detail::forward<Args>(args)...);
+        }
+        /// @}
+
+        namespace literals
+        {
+            /// Syntax sugar to express sizes with unit prefixes.
+            /// \returns The number of bytes `value` is in the given unit.
+            /// \ingroup core
+            /// @{
+            constexpr std::size_t operator"" _KiB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1024);
+            }
+
+            constexpr std::size_t operator"" _KB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1000);
+            }
+
+            constexpr std::size_t operator"" _MiB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1024 * 1024);
+            }
+
+            constexpr std::size_t operator"" _MB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1000 * 1000);
+            }
+
+            constexpr std::size_t operator"" _GiB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1024 * 1024 * 1024);
+            }
+
+            constexpr std::size_t operator"" _GB(unsigned long long value) noexcept
+            {
+                return std::size_t(value * 1000 * 1000 * 1000);
+            }
+        } // namespace literals
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_ARENA_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool.hpp
new file mode 100644
index 0000000..09c2b66
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool.hpp
@@ -0,0 +1,433 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_POOL_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_POOL_HPP_INCLUDED
+
+// Inform that wpi::memory::memory_pool::min_block_size API is available
+#define WPI_MEMORY_MEMORY_POOL_HAS_MIN_BLOCK_SIZE
+
+/// \file
+/// Class \ref wpi::memory::memory_pool and its \ref wpi::memory::allocator_traits specialization.
+
+#include <type_traits>
+
+#include "detail/align.hpp"
+#include "detail/debug_helpers.hpp"
+#include "detail/assert.hpp"
+#include "config.hpp"
+#include "error.hpp"
+#include "memory_arena.hpp"
+#include "memory_pool_type.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            struct memory_pool_leak_handler
+            {
+                void operator()(std::ptrdiff_t amount);
+            };
+        } // namespace detail
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that manages \concept{concept_node,nodes} of fixed size.
+        /// It uses a \ref memory_arena with a given \c BlockOrRawAllocator defaulting to \ref growing_block_allocator,
+        /// subdivides them in small nodes of given size and puts them onto a free list.
+        /// Allocation and deallocation simply remove or add nodes from this list and are thus fast.
+        /// The way the list is maintained can be controlled via the \c PoolType
+        /// which is either \ref node_pool, \ref array_pool or \ref small_node_pool.<br>
+        /// This kind of allocator is ideal for fixed size allocations and deallocations in any order,
+        /// for example in a node based container like \c std::list.
+        /// It is not so good for different allocation sizes and has some drawbacks for arrays
+        /// as described in \ref memory_pool_type.hpp.
+        /// \ingroup allocator
+        template <typename PoolType = node_pool, class BlockOrRawAllocator = default_allocator>
+        class memory_pool
+        : WPI_EBO(detail::default_leak_checker<detail::memory_pool_leak_handler>)
+        {
+            using free_list    = typename PoolType::type;
+            using leak_checker = detail::default_leak_checker<detail::memory_pool_leak_handler>;
+
+        public:
+            using allocator_type = make_block_allocator_t<BlockOrRawAllocator>;
+            using pool_type      = PoolType;
+
+            static constexpr std::size_t min_node_size =
+                WPI_IMPL_DEFINED(free_list::min_element_size);
+
+            /// \returns The minimum block size required for certain number of \concept{concept_node,node}.
+            /// \requires \c node_size must be a valid \concept{concept_node,node size}
+            /// and \c number_of_nodes must be a non-zero value.
+            /// \note MSVC's implementation of \c std::list for example is never empty and always allocates proxy nodes.
+            /// To get enough memory for \c N elements of a list, \c number_of_nodes needs to include the proxy count in addition to \c N.
+            static constexpr std::size_t min_block_size(std::size_t node_size,
+                                                        std::size_t number_of_nodes) noexcept
+            {
+                return detail::memory_block_stack::implementation_offset()
+                       + free_list::min_block_size(node_size, number_of_nodes);
+            }
+
+            /// \effects Creates it by specifying the size each \concept{concept_node,node} will have,
+            /// the initial block size for the arena and other constructor arguments for the \concept{concept_blockallocator,BlockAllocator}.
+            /// If the \c node_size is less than the \c min_node_size, the \c min_node_size will be the actual node size.
+            /// It will allocate an initial memory block with given size from the \concept{concept_blockallocator,BlockAllocator}
+            /// and puts it onto the free list.
+            /// \requires \c node_size must be a valid \concept{concept_node,node size}
+            /// and \c block_size must be at least \c min_block_size(node_size, 1).
+            template <typename... Args>
+            memory_pool(std::size_t node_size, std::size_t block_size, Args&&... args)
+            : arena_(block_size, detail::forward<Args>(args)...), free_list_(node_size)
+            {
+                allocate_block();
+            }
+
+            /// \effects Destroys the \ref memory_pool by returning all memory blocks,
+            /// regardless of properly deallocated back to the \concept{concept_blockallocator,BlockAllocator}.
+            ~memory_pool() noexcept {}
+
+            /// @{
+            /// \effects Moving a \ref memory_pool object transfers ownership over the free list,
+            /// i.e. the moved from pool is completely empty and the new one has all its memory.
+            /// That means that it is not allowed to call \ref deallocate_node() on a moved-from allocator
+            /// even when passing it memory that was previously allocated by this object.
+            memory_pool(memory_pool&& other) noexcept
+            : leak_checker(detail::move(other)),
+              arena_(detail::move(other.arena_)),
+              free_list_(detail::move(other.free_list_))
+            {
+            }
+
+            memory_pool& operator=(memory_pool&& other) noexcept
+            {
+                leak_checker::operator=(detail::move(other));
+                arena_                = detail::move(other.arena_);
+                free_list_            = detail::move(other.free_list_);
+                return *this;
+            }
+            /// @}
+
+            /// \effects Allocates a single \concept{concept_node,node} by removing it from the free list.
+            /// If the free list is empty, a new memory block will be allocated from the arena and put onto it.
+            /// The new block size will be \ref next_capacity() big.
+            /// \returns A node of size \ref node_size() suitable aligned,
+            /// i.e. suitable for any type where <tt>sizeof(T) < node_size()</tt>.
+            /// \throws Anything thrown by the used \concept{concept_blockallocator,BlockAllocator}'s allocation function if a growth is needed.
+            void* allocate_node()
+            {
+                if (free_list_.empty())
+                    allocate_block();
+                WPI_MEMORY_ASSERT(!free_list_.empty());
+                return free_list_.allocate();
+            }
+
+            /// \effects Allocates a single \concept{concept_node,node} similar to \ref allocate_node().
+            /// But if the free list is empty, a new block will *not* be allocated.
+            /// \returns A suitable aligned node of size \ref node_size() or `nullptr`.
+            void* try_allocate_node() noexcept
+            {
+                return free_list_.empty() ? nullptr : free_list_.allocate();
+            }
+
+            /// \effects Allocates an \concept{concept_array,array} of nodes by searching for \c n continuous nodes on the list and removing them.
+            /// Depending on the \c PoolType this can be a slow operation or not allowed at all.
+            /// This can sometimes lead to a growth, even if technically there is enough continuous memory on the free list.
+            /// \returns An array of \c n nodes of size \ref node_size() suitable aligned.
+            /// \throws Anything thrown by the used \concept{concept_blockallocator,BlockAllocator}'s allocation function if a growth is needed,
+            /// or \ref bad_array_size if <tt>n * node_size()</tt> is too big.
+            /// \requires \c n must be valid \concept{concept_array,array count}.
+            void* allocate_array(std::size_t n)
+            {
+                detail::check_allocation_size<bad_array_size>(
+                    n * node_size(), [&] { return pool_type::value ? next_capacity() : 0; },
+                    info());
+                return allocate_array(n, node_size());
+            }
+
+            /// \effects Allocates an \concept{concept_array,array} of nodes similar to \ref allocate_array().
+            /// But it will never allocate a new memory block.
+            /// \returns An array of \c n nodes of size \ref node_size() suitable aligned
+            /// or `nullptr`.
+            void* try_allocate_array(std::size_t n) noexcept
+            {
+                return try_allocate_array(n, node_size());
+            }
+
+            /// \effects Deallocates a single \concept{concept_node,node} by putting it back onto the free list.
+            /// \requires \c ptr must be a result from a previous call to \ref allocate_node() on the same free list,
+            /// i.e. either this allocator object or a new object created by moving this to it.
+            void deallocate_node(void* ptr) noexcept
+            {
+                free_list_.deallocate(ptr);
+            }
+
+            /// \effects Deallocates a single \concept{concept_node,node} but it does not be a result of a previous call to \ref allocate_node().
+            /// \returns `true` if the node could be deallocated, `false` otherwise.
+            /// \note Some free list implementations can deallocate any memory,
+            /// doesn't matter where it is coming from.
+            bool try_deallocate_node(void* ptr) noexcept
+            {
+                if (!arena_.owns(ptr))
+                    return false;
+                free_list_.deallocate(ptr);
+                return true;
+            }
+
+            /// \effects Deallocates an \concept{concept_array,array} by putting it back onto the free list.
+            /// \requires \c ptr must be a result from a previous call to \ref allocate_array() with the same \c n on the same free list,
+            /// i.e. either this allocator object or a new object created by moving this to it.
+            void deallocate_array(void* ptr, std::size_t n) noexcept
+            {
+                WPI_MEMORY_ASSERT_MSG(pool_type::value, "does not support array allocations");
+                free_list_.deallocate(ptr, n * node_size());
+            }
+
+            /// \effects Deallocates an \concept{concept_array,array} but it does not be a result of a previous call to \ref allocate_array().
+            /// \returns `true` if the node could be deallocated, `false` otherwise.
+            /// \note Some free list implementations can deallocate any memory,
+            /// doesn't matter where it is coming from.
+            bool try_deallocate_array(void* ptr, std::size_t n) noexcept
+            {
+                return try_deallocate_array(ptr, n, node_size());
+            }
+
+            /// \returns The size of each \concept{concept_node,node} in the pool,
+            /// this is either the same value as in the constructor or \c min_node_size if the value was too small.
+            std::size_t node_size() const noexcept
+            {
+                return free_list_.node_size();
+            }
+
+            /// \effects Returns the total amount of bytes remaining on the free list.
+            /// Divide it by \ref node_size() to get the number of nodes that can be allocated without growing the arena.
+            /// \note Array allocations may lead to a growth even if the capacity_left left is big enough.
+            std::size_t capacity_left() const noexcept
+            {
+                return free_list_.capacity() * node_size();
+            }
+
+            /// \returns The size of the next memory block after the free list gets empty and the arena grows.
+            /// \ref capacity_left() will increase by this amount.
+            /// \note Due to fence memory in debug mode this cannot be just divided by the \ref node_size() to get the number of nodes.
+            std::size_t next_capacity() const noexcept
+            {
+                return free_list_.usable_size(arena_.next_block_size());
+            }
+
+            /// \returns A reference to the \concept{concept_blockallocator,BlockAllocator} used for managing the arena.
+            /// \requires It is undefined behavior to move this allocator out into another object.
+            allocator_type& get_allocator() noexcept
+            {
+                return arena_.get_allocator();
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::memory_pool", this};
+            }
+
+            void allocate_block()
+            {
+                auto mem = arena_.allocate_block();
+                free_list_.insert(static_cast<char*>(mem.memory), mem.size);
+            }
+
+            void* allocate_array(std::size_t n, std::size_t node_size)
+            {
+                auto mem = free_list_.empty() ? nullptr : free_list_.allocate(n * node_size);
+                if (!mem)
+                {
+                    allocate_block();
+                    mem = free_list_.allocate(n * node_size);
+                    if (!mem)
+                        WPI_THROW(bad_array_size(info(), n * node_size, capacity_left()));
+                }
+                return mem;
+            }
+
+            void* try_allocate_array(std::size_t n, std::size_t node_size) noexcept
+            {
+                return !pool_type::value || free_list_.empty() ? nullptr :
+                                                                 free_list_.allocate(n * node_size);
+            }
+
+            bool try_deallocate_array(void* ptr, std::size_t n, std::size_t node_size) noexcept
+            {
+                if (!pool_type::value || !arena_.owns(ptr))
+                    return false;
+                free_list_.deallocate(ptr, n * node_size);
+                return true;
+            }
+
+            memory_arena<allocator_type, false> arena_;
+            free_list                           free_list_;
+
+            friend allocator_traits<memory_pool<PoolType, BlockOrRawAllocator>>;
+            friend composable_allocator_traits<memory_pool<PoolType, BlockOrRawAllocator>>;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class memory_pool<node_pool>;
+        extern template class memory_pool<array_pool>;
+        extern template class memory_pool<small_node_pool>;
+#endif
+
+        template <class Type, class Alloc>
+        constexpr std::size_t memory_pool<Type, Alloc>::min_node_size;
+
+        /// Specialization of the \ref allocator_traits for \ref memory_pool classes.
+        /// \note It is not allowed to mix calls through the specialization and through the member functions,
+        /// i.e. \ref memory_pool::allocate_node() and this \c allocate_node().
+        /// \ingroup allocator
+        template <typename PoolType, class ImplRawAllocator>
+        class allocator_traits<memory_pool<PoolType, ImplRawAllocator>>
+        {
+        public:
+            using allocator_type = memory_pool<PoolType, ImplRawAllocator>;
+            using is_stateful    = std::true_type;
+
+            /// \returns The result of \ref memory_pool::allocate_node().
+            /// \throws Anything thrown by the pool allocation function
+            /// or a \ref bad_allocation_size exception.
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                detail::check_allocation_size<bad_node_size>(size, max_node_size(state),
+                                                             state.info());
+                detail::check_allocation_size<bad_alignment>(
+                    alignment, [&] { return max_alignment(state); }, state.info());
+                auto mem = state.allocate_node();
+                state.on_allocate(size);
+                return mem;
+            }
+
+            /// \effects Forwards to \ref memory_pool::allocate_array()
+            /// with the number of nodes adjusted to be the minimum,
+            /// i.e. when the \c size is less than the \ref memory_pool::node_size().
+            /// \returns A \concept{concept_array,array} with specified properties.
+            /// \requires The \ref memory_pool has to support array allocations.
+            /// \throws Anything thrown by the pool allocation function.
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                detail::check_allocation_size<bad_node_size>(size, max_node_size(state),
+                                                             state.info());
+                detail::check_allocation_size<bad_alignment>(
+                    alignment, [&] { return max_alignment(state); }, state.info());
+                detail::check_allocation_size<bad_array_size>(count * size, max_array_size(state),
+                                                              state.info());
+                auto mem = state.allocate_array(count, size);
+                state.on_allocate(count * size);
+                return mem;
+            }
+
+            /// \effects Just forwards to \ref memory_pool::deallocate_node().
+            static void deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                        std::size_t) noexcept
+            {
+                state.deallocate_node(node);
+                state.on_deallocate(size);
+            }
+
+            /// \effects Forwards to \ref memory_pool::deallocate_array() with the same size adjustment.
+            static void deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                         std::size_t size, std::size_t) noexcept
+            {
+                state.free_list_.deallocate(array, count * size);
+                state.on_deallocate(count * size);
+            }
+
+            /// \returns The maximum size of each node which is \ref memory_pool::node_size().
+            static std::size_t max_node_size(const allocator_type& state) noexcept
+            {
+                return state.node_size();
+            }
+
+            /// \returns An upper bound on the maximum array size which is \ref memory_pool::next_capacity().
+            static std::size_t max_array_size(const allocator_type& state) noexcept
+            {
+                return state.next_capacity();
+            }
+
+            /// \returns The maximum alignment which is the next bigger power of two if less than \c alignof(std::max_align_t)
+            /// or the maximum alignment itself otherwise.
+            static std::size_t max_alignment(const allocator_type& state) noexcept
+            {
+                return state.free_list_.alignment();
+            }
+        };
+
+        /// Specialization of the \ref composable_allocator_traits for \ref memory_pool classes.
+        /// \ingroup allocator
+        template <typename PoolType, class BlockOrRawAllocator>
+        class composable_allocator_traits<memory_pool<PoolType, BlockOrRawAllocator>>
+        {
+            using traits = allocator_traits<memory_pool<PoolType, BlockOrRawAllocator>>;
+
+        public:
+            using allocator_type = memory_pool<PoolType, BlockOrRawAllocator>;
+
+            /// \returns The result of \ref memory_pool::try_allocate_node()
+            /// or `nullptr` if the allocation size was too big.
+            static void* try_allocate_node(allocator_type& state, std::size_t size,
+                                           std::size_t alignment) noexcept
+            {
+                if (size > traits::max_node_size(state) || alignment > traits::max_alignment(state))
+                    return nullptr;
+                return state.try_allocate_node();
+            }
+
+            /// \effects Forwards to \ref memory_pool::try_allocate_array()
+            /// with the number of nodes adjusted to be the minimum,
+            /// if the \c size is less than the \ref memory_pool::node_size().
+            /// \returns A \concept{concept_array,array} with specified properties
+            /// or `nullptr` if it was unable to allocate.
+            static void* try_allocate_array(allocator_type& state, std::size_t count,
+                                            std::size_t size, std::size_t alignment) noexcept
+            {
+                if (size > traits::max_node_size(state)
+                    || count * size > traits::max_array_size(state)
+                    || alignment > traits::max_alignment(state))
+                    return nullptr;
+                return state.try_allocate_array(count, size);
+            }
+
+            /// \effects Just forwards to \ref memory_pool::try_deallocate_node().
+            /// \returns Whether the deallocation was successful.
+            static bool try_deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                            std::size_t alignment) noexcept
+            {
+                if (size > traits::max_node_size(state) || alignment > traits::max_alignment(state))
+                    return false;
+                return state.try_deallocate_node(node);
+            }
+
+            /// \effects Forwards to \ref memory_pool::deallocate_array() with the same size adjustment.
+            /// \returns Whether the deallocation was successful.
+            static bool try_deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                             std::size_t size, std::size_t alignment) noexcept
+            {
+                if (size > traits::max_node_size(state)
+                    || count * size > traits::max_array_size(state)
+                    || alignment > traits::max_alignment(state))
+                    return false;
+                return state.try_deallocate_array(array, count, size);
+            }
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<memory_pool<node_pool>>;
+        extern template class allocator_traits<memory_pool<array_pool>>;
+        extern template class allocator_traits<memory_pool<small_node_pool>>;
+
+        extern template class composable_allocator_traits<memory_pool<node_pool>>;
+        extern template class composable_allocator_traits<memory_pool<array_pool>>;
+        extern template class composable_allocator_traits<memory_pool<small_node_pool>>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_POOL_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_collection.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_collection.hpp
new file mode 100644
index 0000000..294dd0a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_collection.hpp
@@ -0,0 +1,569 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_POOL_COLLECTION_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_POOL_COLLECTION_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::memory_pool_collection and related classes.
+
+#include <type_traits>
+
+#include "detail/align.hpp"
+#include "detail/assert.hpp"
+#include "detail/memory_stack.hpp"
+#include "detail/free_list_array.hpp"
+#include "config.hpp"
+#include "debugging.hpp"
+#include "error.hpp"
+#include "memory_arena.hpp"
+#include "memory_pool_type.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            struct memory_pool_collection_leak_handler
+            {
+                void operator()(std::ptrdiff_t amount);
+            };
+        } // namespace detail
+
+        /// A \c BucketDistribution for \ref memory_pool_collection defining that there is a bucket, i.e. pool, for each size.
+        /// That means that for each possible size up to an upper bound there will be a seperate free list.
+        /// Allocating a node will not waste any memory.
+        /// \ingroup allocator
+        struct identity_buckets
+        {
+            using type = detail::identity_access_policy;
+        };
+
+        /// A \c BucketDistribution for \ref memory_pool_collection defining that there is a bucket, i.e. pool, for each power of two.
+        /// That means for each power of two up to an upper bound there will be a separate free list.
+        /// Allocating a node will only waste half of the memory.
+        /// \ingroup allocator
+        struct log2_buckets
+        {
+            using type = detail::log2_access_policy;
+        };
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that behaves as a collection of multiple \ref memory_pool objects.
+        /// It maintains a list of multiple free lists, whose types are controlled via the \c PoolType tags defined in \ref memory_pool_type.hpp,
+        /// each of a different size as defined in the \c BucketDistribution (\ref identity_buckets or \ref log2_buckets).
+        /// Allocating a node of given size will use the appropriate free list.<br>
+        /// This allocator is ideal for \concept{concept_node,node} allocations in any order but with a predefined set of sizes,
+        /// not only one size like \ref memory_pool.
+        /// \ingroup allocator
+        template <class PoolType, class BucketDistribution,
+                  class BlockOrRawAllocator = default_allocator>
+        class memory_pool_collection
+        : WPI_EBO(detail::default_leak_checker<detail::memory_pool_collection_leak_handler>)
+        {
+            using free_list_array =
+                detail::free_list_array<typename PoolType::type, typename BucketDistribution::type>;
+            using leak_checker =
+                detail::default_leak_checker<detail::memory_pool_collection_leak_handler>;
+
+        public:
+            using allocator_type      = make_block_allocator_t<BlockOrRawAllocator>;
+            using pool_type           = PoolType;
+            using bucket_distribution = BucketDistribution;
+
+            /// \effects Creates it by giving it the maximum node size it should be able to allocate,
+            /// the size of the initial memory block and other constructor arguments for the \concept{concept_blockallocator,BlockAllocator}.
+            /// The \c BucketDistribution controls how many free lists are created,
+            /// but unlike in \ref memory_pool all free lists are initially empty and the first memory block queued.
+            /// \requires \c max_node_size must be a valid \concept{concept_node,node} size
+            /// and \c block_size must be non-zero.
+            template <typename... Args>
+            memory_pool_collection(std::size_t max_node_size, std::size_t block_size,
+                                   Args&&... args)
+            : arena_(block_size, detail::forward<Args>(args)...),
+              stack_(allocate_block()),
+              pools_(stack_, block_end(), max_node_size)
+            {
+            }
+
+            /// \effects Destroys the \ref memory_pool_collection by returning all memory blocks,
+            /// regardless of properly deallocated back to the \concept{concept_blockallocator,BlockAllocator}.
+            ~memory_pool_collection() noexcept = default;
+
+            /// @{
+            /// \effects Moving a \ref memory_pool_collection object transfers ownership over the free lists,
+            /// i.e. the moved from pool is completely empty and the new one has all its memory.
+            /// That means that it is not allowed to call \ref deallocate_node() on a moved-from allocator
+            /// even when passing it memory that was previously allocated by this object.
+            memory_pool_collection(memory_pool_collection&& other) noexcept
+            : leak_checker(detail::move(other)),
+              arena_(detail::move(other.arena_)),
+              stack_(detail::move(other.stack_)),
+              pools_(detail::move(other.pools_))
+            {
+            }
+
+            memory_pool_collection& operator=(memory_pool_collection&& other) noexcept
+            {
+                leak_checker::operator=(detail::move(other));
+                arena_                = detail::move(other.arena_);
+                stack_                = detail::move(other.stack_);
+                pools_                = detail::move(other.pools_);
+                return *this;
+            }
+            /// @}
+
+            /// \effects Allocates a \concept{concept_node,node} of given size.
+            /// It first finds the appropriate free list as defined in the \c BucketDistribution.
+            /// If it is empty, it will use an implementation defined amount of memory from the arena
+            /// and inserts it in it.
+            /// If the arena is empty too, it will request a new memory block from the \concept{concept_blockallocator,BlockAllocator}
+            /// of size \ref next_capacity() and puts part of it onto this free list.
+            /// Then it removes a node from it.
+            /// \returns A \concept{concept_node,node} of given size suitable aligned,
+            /// i.e. suitable for any type where <tt>sizeof(T) < node_size</tt>.
+            /// \throws Anything thrown by the \concept{concept_blockallocator,BlockAllocator} if a growth is needed or a \ref bad_node_size exception if the node size is too big.
+            void* allocate_node(std::size_t node_size)
+            {
+                detail::check_allocation_size<bad_node_size>(
+                    node_size, [&] { return max_node_size(); }, info());
+                auto& pool = pools_.get(node_size);
+                if (pool.empty())
+                {
+                    auto block = reserve_memory(pool, def_capacity());
+                    pool.insert(block.memory, block.size);
+                }
+
+                auto mem = pool.allocate();
+                WPI_MEMORY_ASSERT(mem);
+                return mem;
+            }
+
+            /// \effects Allocates a \concept{concept_node,node} of given size.
+            /// It is similar to \ref allocate_node() but will return `nullptr` on any failure,
+            /// instead of growing the arnea and possibly throwing.
+            /// \returns A \concept{concept_node,node} of given size suitable aligned
+            /// or `nullptr` in case of failure.
+            void* try_allocate_node(std::size_t node_size) noexcept
+            {
+                if (node_size > max_node_size())
+                    return nullptr;
+                auto& pool = pools_.get(node_size);
+                if (pool.empty())
+                {
+                    try_reserve_memory(pool, def_capacity());
+                    return pool.empty() ? nullptr : pool.allocate();
+                }
+                else
+                    return pool.allocate();
+            }
+
+            /// \effects Allocates an \concept{concept_array,array} of nodes by searching for \c n continuous nodes on the appropriate free list and removing them.
+            /// Depending on the \c PoolType this can be a slow operation or not allowed at all.
+            /// This can sometimes lead to a growth on the free list, even if technically there is enough continuous memory on the free list.
+            /// Otherwise has the same behavior as \ref allocate_node().
+            /// \returns An array of \c n nodes of size \c node_size suitable aligned.
+            /// \throws Anything thrown by the used \concept{concept_blockallocator,BlockAllocator}'s allocation function if a growth is needed,
+            /// or a \ref bad_allocation_size exception.
+            /// \requires \c count must be valid \concept{concept_array,array count} and
+            /// \c node_size must be valid \concept{concept_node,node size}.
+            void* allocate_array(std::size_t count, std::size_t node_size)
+            {
+                detail::check_allocation_size<bad_node_size>(
+                    node_size, [&] { return max_node_size(); }, info());
+
+                auto& pool = pools_.get(node_size);
+
+                // try allocating if not empty
+                // for pools without array allocation support, allocate() will always return nullptr
+                auto mem = pool.empty() ? nullptr : pool.allocate(count * node_size);
+                if (!mem)
+                {
+                    // reserve more memory
+                    auto block = reserve_memory(pool, def_capacity());
+                    pool.insert(block.memory, block.size);
+
+                    mem = pool.allocate(count * node_size);
+                    if (!mem)
+                    {
+                        // reserve more then the default capacity if that didn't work either
+                        detail::check_allocation_size<bad_array_size>(
+                            count * node_size,
+                            [&] { return next_capacity() - pool.alignment() + 1; }, info());
+
+                        block = reserve_memory(pool, count * node_size);
+                        pool.insert(block.memory, block.size);
+
+                        mem = pool.allocate(count * node_size);
+                        WPI_MEMORY_ASSERT(mem);
+                    }
+                }
+
+                return mem;
+            }
+
+            /// \effects Allocates a \concept{concept_array,array} of given size.
+            /// It is similar to \ref allocate_node() but will return `nullptr` on any failure,
+            /// instead of growing the arnea and possibly throwing.
+            /// \returns A \concept{concept_array,array} of given size suitable aligned
+            /// or `nullptr` in case of failure.
+            void* try_allocate_array(std::size_t count, std::size_t node_size) noexcept
+            {
+                if (!pool_type::value || node_size > max_node_size())
+                    return nullptr;
+                auto& pool = pools_.get(node_size);
+                if (pool.empty())
+                {
+                    try_reserve_memory(pool, def_capacity());
+                    return pool.empty() ? nullptr : pool.allocate(count * node_size);
+                }
+                else
+                    return pool.allocate(count * node_size);
+            }
+
+            /// \effects Deallocates a \concept{concept_node,node} by putting it back onto the appropriate free list.
+            /// \requires \c ptr must be a result from a previous call to \ref allocate_node() with the same size on the same free list,
+            /// i.e. either this allocator object or a new object created by moving this to it.
+            void deallocate_node(void* ptr, std::size_t node_size) noexcept
+            {
+                pools_.get(node_size).deallocate(ptr);
+            }
+
+            /// \effects Deallocates a \concept{concept_node,node} similar to \ref deallocate_node().
+            /// But it checks if it can deallocate this memory.
+            /// \returns `true` if the node could be deallocated,
+            /// `false` otherwise.
+            bool try_deallocate_node(void* ptr, std::size_t node_size) noexcept
+            {
+                if (node_size > max_node_size() || !arena_.owns(ptr))
+                    return false;
+                pools_.get(node_size).deallocate(ptr);
+                return true;
+            }
+
+            /// \effects Deallocates an \concept{concept_array,array} by putting it back onto the free list.
+            /// \requires \c ptr must be a result from a previous call to \ref allocate_array() with the same sizes on the same free list,
+            /// i.e. either this allocator object or a new object created by moving this to it.
+            void deallocate_array(void* ptr, std::size_t count, std::size_t node_size) noexcept
+            {
+                pools_.get(node_size).deallocate(ptr, count * node_size);
+            }
+
+            /// \effects Deallocates a \concept{concept_array,array} similar to \ref deallocate_array().
+            /// But it checks if it can deallocate this memory.
+            /// \returns `true` if the array could be deallocated,
+            /// `false` otherwise.
+            bool try_deallocate_array(void* ptr, std::size_t count, std::size_t node_size) noexcept
+            {
+                if (!pool_type::value || node_size > max_node_size() || !arena_.owns(ptr))
+                    return false;
+                pools_.get(node_size).deallocate(ptr, count * node_size);
+                return true;
+            }
+
+            /// \effects Inserts more memory on the free list for nodes of given size.
+            /// It will try to put \c capacity_left bytes from the arena onto the free list defined over the \c BucketDistribution,
+            /// if the arena is empty, a new memory block is requested from the \concept{concept_blockallocator,BlockAllocator}
+            /// and it will be used.
+            /// \throws Anything thrown by the \concept{concept_blockallocator,BlockAllocator} if a growth is needed.
+            /// \requires \c node_size must be valid \concept{concept_node,node size} less than or equal to \ref max_node_size(),
+            /// \c capacity_left must be less than \ref next_capacity().
+            void reserve(std::size_t node_size, std::size_t capacity)
+            {
+                WPI_MEMORY_ASSERT_MSG(node_size <= max_node_size(), "node_size too big");
+                auto& pool = pools_.get(node_size);
+                reserve_memory(pool, capacity);
+            }
+
+            /// \returns The maximum node size for which is a free list.
+            /// This is the value passed to it in the constructor.
+            std::size_t max_node_size() const noexcept
+            {
+                return pools_.max_node_size();
+            }
+
+            /// \returns The amount of nodes available in the free list for nodes of given size
+            /// as defined over the \c BucketDistribution.
+            /// This is the number of nodes that can be allocated without the free list requesting more memory from the arena.
+            /// \note Array allocations may lead to a growth even if the capacity_left is big enough.
+            std::size_t pool_capacity_left(std::size_t node_size) const noexcept
+            {
+                WPI_MEMORY_ASSERT_MSG(node_size <= max_node_size(), "node_size too big");
+                return pools_.get(node_size).capacity();
+            }
+
+            /// \returns The amount of memory available in the arena not inside the free lists.
+            /// This is the number of bytes that can be inserted into the free lists
+            /// without requesting more memory from the \concept{concept_blockallocator,BlockAllocator}.
+            /// \note Array allocations may lead to a growth even if the capacity is big enough.
+            std::size_t capacity_left() const noexcept
+            {
+                return std::size_t(block_end() - stack_.top());
+            }
+
+            /// \returns The size of the next memory block after \ref capacity_left() arena grows.
+            /// This is the amount of memory that can be distributed in the pools.
+            /// \note If the `PoolType` is \ref small_node_pool, the exact usable memory is lower than that.
+            std::size_t next_capacity() const noexcept
+            {
+                return arena_.next_block_size();
+            }
+
+            /// \returns A reference to the \concept{concept_blockallocator,BlockAllocator} used for managing the arena.
+            /// \requires It is undefined behavior to move this allocator out into another object.
+            allocator_type& get_allocator() noexcept
+            {
+                return arena_.get_allocator();
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::memory_pool_collection", this};
+            }
+
+            std::size_t def_capacity() const noexcept
+            {
+                return arena_.next_block_size() / pools_.size();
+            }
+
+            detail::fixed_memory_stack allocate_block()
+            {
+                return detail::fixed_memory_stack(arena_.allocate_block().memory);
+            }
+
+            const char* block_end() const noexcept
+            {
+                auto block = arena_.current_block();
+                return static_cast<const char*>(block.memory) + block.size;
+            }
+
+            bool insert_rest(typename pool_type::type& pool) noexcept
+            {
+                if (auto remaining = std::size_t(block_end() - stack_.top()))
+                {
+                    auto offset = detail::align_offset(stack_.top(), detail::max_alignment);
+                    if (offset < remaining)
+                    {
+                        detail::debug_fill(stack_.top(), offset, debug_magic::alignment_memory);
+                        pool.insert(stack_.top() + offset, remaining - offset);
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            void try_reserve_memory(typename pool_type::type& pool, std::size_t capacity) noexcept
+            {
+                auto mem = stack_.allocate(block_end(), capacity, detail::max_alignment);
+                if (!mem)
+                    insert_rest(pool);
+                else
+                    pool.insert(mem, capacity);
+            }
+
+            memory_block reserve_memory(typename pool_type::type& pool, std::size_t capacity)
+            {
+                auto mem = stack_.allocate(block_end(), capacity, detail::max_alignment);
+                if (!mem)
+                {
+                    insert_rest(pool);
+                    // get new block
+                    stack_ = allocate_block();
+
+                    // allocate ensuring alignment
+                    mem = stack_.allocate(block_end(), capacity, detail::max_alignment);
+                    WPI_MEMORY_ASSERT(mem);
+                }
+                return {mem, capacity};
+            }
+
+            memory_arena<allocator_type, false> arena_;
+            detail::fixed_memory_stack          stack_;
+            free_list_array                     pools_;
+
+            friend allocator_traits<memory_pool_collection>;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class memory_pool_collection<node_pool, identity_buckets>;
+        extern template class memory_pool_collection<array_pool, identity_buckets>;
+        extern template class memory_pool_collection<small_node_pool, identity_buckets>;
+
+        extern template class memory_pool_collection<node_pool, log2_buckets>;
+        extern template class memory_pool_collection<array_pool, log2_buckets>;
+        extern template class memory_pool_collection<small_node_pool, log2_buckets>;
+#endif
+
+        /// An alias for \ref memory_pool_collection using the \ref identity_buckets policy
+        /// and a \c PoolType defaulting to \ref node_pool.
+        /// \ingroup allocator
+        template <class PoolType = node_pool, class ImplAllocator = default_allocator>
+        WPI_ALIAS_TEMPLATE(bucket_allocator,
+                                 memory_pool_collection<PoolType, identity_buckets, ImplAllocator>);
+
+        template <class Allocator>
+        class allocator_traits;
+
+        /// Specialization of the \ref allocator_traits for \ref memory_pool_collection classes.
+        /// \note It is not allowed to mix calls through the specialization and through the member functions,
+        /// i.e. \ref memory_pool_collection::allocate_node() and this \c allocate_node().
+        /// \ingroup allocator
+        template <class Pool, class BucketDist, class RawAllocator>
+        class allocator_traits<memory_pool_collection<Pool, BucketDist, RawAllocator>>
+        {
+        public:
+            using allocator_type = memory_pool_collection<Pool, BucketDist, RawAllocator>;
+            using is_stateful    = std::true_type;
+
+            /// \returns The result of \ref memory_pool_collection::allocate_node().
+            /// \throws Anything thrown by the pool allocation function
+            /// or a \ref bad_allocation_size exception if \c size / \c alignment exceeds \ref max_node_size() / the suitable alignment value,
+            /// i.e. the node is over-aligned.
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                // node already checked
+                detail::check_allocation_size<bad_alignment>(
+                    alignment, [&] { return detail::alignment_for(size); }, state.info());
+                auto mem = state.allocate_node(size);
+                state.on_allocate(size);
+                return mem;
+            }
+
+            /// \returns The result of \ref memory_pool_collection::allocate_array().
+            /// \throws Anything thrown by the pool allocation function or a \ref bad_allocation_size exception.
+            /// \requires The \ref memory_pool_collection has to support array allocations.
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                // node and array already checked
+                detail::check_allocation_size<bad_alignment>(
+                    alignment, [&] { return detail::alignment_for(size); }, state.info());
+                auto mem = state.allocate_array(count, size);
+                state.on_allocate(count * size);
+                return mem;
+            }
+
+            /// \effects Calls \ref memory_pool_collection::deallocate_node().
+            static void deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                        std::size_t) noexcept
+            {
+                state.deallocate_node(node, size);
+                state.on_deallocate(size);
+            }
+
+            /// \effects Calls \ref memory_pool_collection::deallocate_array().
+            /// \requires The \ref memory_pool_collection has to support array allocations.
+            static void deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                         std::size_t size, std::size_t) noexcept
+            {
+                state.deallocate_array(array, count, size);
+                state.on_deallocate(count * size);
+            }
+
+            /// \returns The maximum size of each node which is \ref memory_pool_collection::max_node_size().
+            static std::size_t max_node_size(const allocator_type& state) noexcept
+            {
+                return state.max_node_size();
+            }
+
+            /// \returns An upper bound on the maximum array size which is \ref memory_pool::next_capacity().
+            static std::size_t max_array_size(const allocator_type& state) noexcept
+            {
+                return state.next_capacity();
+            }
+
+            /// \returns Just \c alignof(std::max_align_t) since the actual maximum alignment depends on the node size,
+            /// the nodes must not be over-aligned.
+            static std::size_t max_alignment(const allocator_type&) noexcept
+            {
+                return detail::max_alignment;
+            }
+        };
+
+        /// Specialization of the \ref composable_allocator_traits for \ref memory_pool_collection classes.
+        /// \ingroup allocator
+        template <class Pool, class BucketDist, class RawAllocator>
+        class composable_allocator_traits<memory_pool_collection<Pool, BucketDist, RawAllocator>>
+        {
+            using traits = allocator_traits<memory_pool_collection<Pool, BucketDist, RawAllocator>>;
+
+        public:
+            using allocator_type = memory_pool_collection<Pool, BucketDist, RawAllocator>;
+
+            /// \returns The result of \ref memory_pool_collection::try_allocate_node()
+            /// or `nullptr` if the allocation size was too big.
+            static void* try_allocate_node(allocator_type& state, std::size_t size,
+                                           std::size_t alignment) noexcept
+            {
+                if (alignment > traits::max_alignment(state))
+                    return nullptr;
+                return state.try_allocate_node(size);
+            }
+
+            /// \returns The result of \ref memory_pool_collection::try_allocate_array()
+            /// or `nullptr` if the allocation size was too big.
+            static void* try_allocate_array(allocator_type& state, std::size_t count,
+                                            std::size_t size, std::size_t alignment) noexcept
+            {
+                if (count * size > traits::max_array_size(state)
+                    || alignment > traits::max_alignment(state))
+                    return nullptr;
+                return state.try_allocate_array(count, size);
+            }
+
+            /// \effects Just forwards to \ref memory_pool_collection::try_deallocate_node().
+            /// \returns Whether the deallocation was successful.
+            static bool try_deallocate_node(allocator_type& state, void* node, std::size_t size,
+                                            std::size_t alignment) noexcept
+            {
+                if (alignment > traits::max_alignment(state))
+                    return false;
+                return state.try_deallocate_node(node, size);
+            }
+
+            /// \effects Forwards to \ref memory_pool_collection::deallocate_array().
+            /// \returns Whether the deallocation was successful.
+            static bool try_deallocate_array(allocator_type& state, void* array, std::size_t count,
+                                             std::size_t size, std::size_t alignment) noexcept
+            {
+                if (count * size > traits::max_array_size(state)
+                    || alignment > traits::max_alignment(state))
+                    return false;
+                return state.try_deallocate_array(array, count, size);
+            }
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<memory_pool_collection<node_pool, identity_buckets>>;
+        extern template class allocator_traits<
+            memory_pool_collection<array_pool, identity_buckets>>;
+        extern template class allocator_traits<
+            memory_pool_collection<small_node_pool, identity_buckets>>;
+
+        extern template class allocator_traits<memory_pool_collection<node_pool, log2_buckets>>;
+        extern template class allocator_traits<memory_pool_collection<array_pool, log2_buckets>>;
+        extern template class allocator_traits<
+            memory_pool_collection<small_node_pool, log2_buckets>>;
+
+        extern template class composable_allocator_traits<
+            memory_pool_collection<node_pool, identity_buckets>>;
+        extern template class composable_allocator_traits<
+            memory_pool_collection<array_pool, identity_buckets>>;
+        extern template class composable_allocator_traits<
+            memory_pool_collection<small_node_pool, identity_buckets>>;
+
+        extern template class composable_allocator_traits<
+            memory_pool_collection<node_pool, log2_buckets>>;
+        extern template class composable_allocator_traits<
+            memory_pool_collection<array_pool, log2_buckets>>;
+        extern template class composable_allocator_traits<
+            memory_pool_collection<small_node_pool, log2_buckets>>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_POOL_COLLECTION_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_type.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_type.hpp
new file mode 100644
index 0000000..a7c8ff8
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_pool_type.hpp
@@ -0,0 +1,53 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_POOL_TYPE_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_POOL_TYPE_HPP_INCLUDED
+
+/// \file
+/// The \c PoolType tag types.
+
+#include <type_traits>
+
+#include "detail/free_list.hpp"
+#include "detail/small_free_list.hpp"
+#include "config.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// Tag type defining a memory pool optimized for nodes.
+        /// It does not support array allocations that great and may trigger a growth even if there is enough memory.
+        /// But it is the fastest pool type.
+        /// \ingroup allocator
+        struct node_pool : WPI_EBO(std::true_type)
+        {
+            using type = detail::node_free_memory_list;
+        };
+
+        /// Tag type defining a memory pool optimized for arrays.
+        /// It keeps the nodes oredered inside the free list and searches the list for an appropriate memory block.
+        /// Array allocations are still pretty slow, if the array gets big enough it can get slower than \c new.
+        /// Node allocations are still fast, unless there is deallocation in random order.
+        /// \note Use this tag type only if you really need to have a memory pool!
+        /// \ingroup allocator
+        struct array_pool : WPI_EBO(std::true_type)
+        {
+            using type = detail::array_free_memory_list;
+        };
+
+        /// Tag type defining a memory pool optimized for small nodes.
+        /// The free list is intrusive and thus requires that each node has at least the size of a pointer.
+        /// This tag type does not have this requirement and thus allows zero-memory-overhead allocations of small nodes.
+        /// It is a little bit slower than \ref node_pool and does not support arrays.
+        /// \ingroup allocator
+        struct small_node_pool : WPI_EBO(std::false_type)
+        {
+            using type = detail::small_free_memory_list;
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_POOL_TYPE_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_resource_adapter.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_resource_adapter.hpp
new file mode 100644
index 0000000..e805f9b
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_resource_adapter.hpp
@@ -0,0 +1,239 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_RESOURCE_ADAPTER_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_RESOURCE_ADAPTER_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::memory_resource_adapter and \ref wpi::memory::memory_resource_allocator to allow usage of PMRs.
+
+#include "detail/assert.hpp"
+#include "detail/utility.hpp"
+#include "config.hpp"
+#include "allocator_traits.hpp"
+
+#if defined(__has_include) && __has_include(<memory_resource>)
+
+#if !defined(__GNUC__) || __cplusplus >= 201703L
+// The experimental/memory_resource header lacks a check for C++17 on older GCC,
+// so we have to do it for them.
+#include <memory_resource>
+#endif
+
+#elif defined(__has_include) && __has_include(<experimental/memory_resource>)
+
+#if !defined(__GNUC__) || __cplusplus >= 201402L
+// The experimental/memory_resource header lacks a check for C++14 on older GCC,
+// so we have to do it for them.
+#include <experimental/memory_resource>
+#endif
+
+#endif
+
+#if defined(__cpp_lib_memory_resource)
+
+// We use std::pmr::memory_resource.
+namespace wpi_memory_pmr = std::pmr;
+
+#elif defined(__cpp_lib_experimental_memory_resources)
+
+// We use std::experimental::pmr::memory_resource.
+namespace wpi_memory_pmr = std::experimental::pmr;
+
+#else
+
+// We use our own implementation.
+namespace wpi_memory_pmr
+{
+    // see N3916 for documentation
+    class memory_resource
+    {
+        static const std::size_t max_alignment = alignof(std::max_align_t);
+
+    public:
+        virtual ~memory_resource() noexcept {}
+        void* allocate(std::size_t bytes, std::size_t alignment = max_alignment)
+        {
+            return do_allocate(bytes, alignment);
+        }
+        void deallocate(void* p, std::size_t bytes, std::size_t alignment = max_alignment)
+        {
+            do_deallocate(p, bytes, alignment);
+        }
+        bool is_equal(const memory_resource& other) const noexcept
+        {
+            return do_is_equal(other);
+        }
+
+    protected:
+        virtual void* do_allocate(std::size_t bytes, std::size_t alignment)            = 0;
+        virtual void  do_deallocate(void* p, std::size_t bytes, std::size_t alignment) = 0;
+        virtual bool  do_is_equal(const memory_resource& other) const noexcept         = 0;
+    };
+    inline bool operator==(const memory_resource& a, const memory_resource& b) noexcept
+    {
+        return &a == &b || a.is_equal(b);
+    }
+    inline bool operator!=(const memory_resource& a, const memory_resource& b) noexcept
+    {
+        return !(a == b);
+    }
+} // namespace wpi_memory_pmr
+
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// The \c memory_resource abstract base class used in the implementation.
+        /// \ingroup adapter
+        WPI_ALIAS_TEMPLATE(memory_resource, foonathan_memory_pmr::memory_resource);
+
+        /// Wraps a \concept{concept_rawallocator,RawAllocator} and makes it a \ref memory_resource.
+        /// \ingroup adapter
+        template <class RawAllocator>
+        class memory_resource_adapter
+        : public memory_resource,
+          WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+
+            /// \effects Creates the resource by moving in the allocator.
+            memory_resource_adapter(allocator_type&& other) noexcept
+            : allocator_type(detail::move(other))
+            {
+            }
+
+            /// @{
+            /// \returns A reference to the wrapped allocator.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+        protected:
+            using traits_type = allocator_traits<RawAllocator>;
+
+            /// \effects Allocates raw memory with given size and alignment.
+            /// It forwards to \c allocate_node() or \c allocate_array() depending on the size.
+            /// \returns The new memory as returned by the \concept{concept_rawallocator,RawAllocator}.
+            /// \throws Anything thrown by the allocation function.
+            void* do_allocate(std::size_t bytes, std::size_t alignment) override
+            {
+                auto max = traits_type::max_node_size(*this);
+                if (bytes <= max)
+                    return traits_type::allocate_node(*this, bytes, alignment);
+                auto div = bytes / max;
+                auto mod = bytes % max;
+                auto n   = div + (mod != 0);
+                return traits_type::allocate_array(*this, n, max, alignment);
+            }
+
+            /// \effects Deallocates memory previously allocated by \ref do_allocate.
+            /// It forwards to \c deallocate_node() or \c deallocate_array() depending on the size.
+            /// \throws Nothing.
+            void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override
+            {
+                auto max = traits_type::max_node_size(*this);
+                if (bytes <= max)
+                    traits_type::deallocate_node(*this, p, bytes, alignment);
+                else
+                {
+                    auto div = bytes / max;
+                    auto mod = bytes % max;
+                    auto n   = div + (mod != 0);
+                    traits_type::deallocate_array(*this, p, n, max, alignment);
+                }
+            }
+
+            /// \returns Whether or not \c *this is equal to \c other
+            /// by comparing the addresses.
+            bool do_is_equal(const memory_resource& other) const noexcept override
+            {
+                return this == &other;
+            }
+        };
+
+        /// Wraps a \ref memory_resource and makes it a \concept{concept_rawallocator,RawAllocator}.
+        /// \ingroup adapter
+        class memory_resource_allocator
+        {
+        public:
+            /// \effects Creates it by giving it a pointer to the \ref memory_resource.
+            /// \requires \c ptr must not be \c nullptr.
+            memory_resource_allocator(memory_resource* ptr) noexcept : ptr_(ptr)
+            {
+                WPI_MEMORY_ASSERT(ptr);
+            }
+
+            /// \effects Allocates a node by forwarding to the \c allocate() function.
+            /// \returns The node as returned by the \ref memory_resource.
+            /// \throws Anything thrown by the \c allocate() function.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                return ptr_->allocate(size, alignment);
+            }
+
+            /// \effects Deallocates a node by forwarding to the \c deallocate() function.
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                ptr_->deallocate(ptr, size, alignment);
+            }
+
+            /// \returns The maximum alignment which is the maximum value of type \c std::size_t.
+            std::size_t max_alignment() const noexcept
+            {
+                return std::size_t(-1);
+            }
+
+            /// \returns A pointer to the used \ref memory_resource, this is never \c nullptr.
+            memory_resource* resource() const noexcept
+            {
+                return ptr_;
+            }
+
+        private:
+            memory_resource* ptr_;
+        };
+
+        /// @{
+        /// \returns Whether `lhs` and `rhs` share the same resource.
+        /// \relates memory_resource_allocator
+        inline bool operator==(const memory_resource_allocator& lhs,
+                               const memory_resource_allocator& rhs) noexcept
+        {
+            return lhs.resource() == rhs.resource();
+        }
+
+        inline bool operator!=(const memory_resource_allocator& lhs,
+                               const memory_resource_allocator& rhs) noexcept
+        {
+            return !(lhs == rhs);
+        }
+        /// @}
+
+#if !defined(DOXYGEN)
+        template <class RawAllocator>
+        struct is_shared_allocator;
+#endif
+
+        /// Specialization of \ref is_shared_allocator to mark \ref memory_resource_allocator as shared.
+        /// This allows using it as \ref allocator_reference directly.
+        /// \ingroup adapter
+        template <>
+        struct is_shared_allocator<memory_resource_allocator> : std::true_type
+        {
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_RESOURCE_ADAPTER_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_stack.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_stack.hpp
new file mode 100644
index 0000000..4c9f524
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/memory_stack.hpp
@@ -0,0 +1,489 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_MEMORY_STACK_HPP_INCLUDED
+#define WPI_MEMORY_MEMORY_STACK_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::memory_stack and its \ref wpi::memory::allocator_traits specialization.
+
+// Inform that wpi::memory::memory_stack::min_block_size API is available
+#define WPI_MEMORY_MEMORY_STACK_HAS_MIN_BLOCK_SIZE
+
+#include <cstdint>
+#include <type_traits>
+
+#include "detail/assert.hpp"
+#include "detail/memory_stack.hpp"
+#include "config.hpp"
+#include "error.hpp"
+#include "memory_arena.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+#if !defined(DOXYGEN)
+        template <class Impl>
+        class memory_stack;
+#endif
+
+        namespace detail
+        {
+            class stack_marker
+            {
+                std::size_t index;
+                char*       top;
+                const char* end;
+
+                stack_marker(std::size_t i, const detail::fixed_memory_stack& s,
+                             const char* e) noexcept
+                : index(i), top(s.top()), end(e)
+                {
+                }
+
+                friend bool operator==(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    if (lhs.index != rhs.index)
+                        return false;
+                    WPI_MEMORY_ASSERT_MSG(lhs.end == rhs.end, "you must not compare two "
+                                                                    "stack markers from different "
+                                                                    "stacks");
+                    return lhs.top == rhs.top;
+                }
+
+                friend bool operator!=(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    return !(rhs == lhs);
+                }
+
+                friend bool operator<(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    if (lhs.index != rhs.index)
+                        return lhs.index < rhs.index;
+                    WPI_MEMORY_ASSERT_MSG(lhs.end == rhs.end, "you must not compare two "
+                                                                    "stack markers from different "
+                                                                    "stacks");
+                    return lhs.top < rhs.top;
+                }
+
+                friend bool operator>(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    return rhs < lhs;
+                }
+
+                friend bool operator<=(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    return !(rhs < lhs);
+                }
+
+                friend bool operator>=(const stack_marker& lhs, const stack_marker& rhs) noexcept
+                {
+                    return !(lhs < rhs);
+                }
+
+                template <class Impl>
+                friend class memory::memory_stack;
+            };
+
+            struct memory_stack_leak_handler
+            {
+                void operator()(std::ptrdiff_t amount);
+            };
+        } // namespace detail
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that provides stack-like (LIFO) allocations.
+        /// It uses a \ref memory_arena with a given \c BlockOrRawAllocator defaulting to \ref growing_block_allocator to allocate huge blocks
+        /// and saves a marker to the current top.
+        /// Allocation simply moves this marker by the appropriate number of bytes and returns the pointer at the old marker position,
+        /// deallocation is not directly supported, only setting the marker to a previously queried position.
+        /// \ingroup allocator
+        template <class BlockOrRawAllocator = default_allocator>
+        class memory_stack
+        : WPI_EBO(detail::default_leak_checker<detail::memory_stack_leak_handler>)
+        {
+        public:
+            using allocator_type = make_block_allocator_t<BlockOrRawAllocator>;
+
+            /// \returns The minimum block size required for a stack containing the given amount of memory.
+            /// If a stack is created with the result of `min_block_size(n)`, the resulting capacity will be exactly `n`.
+            /// \requires `byte_size` must be a positive number.
+            /// \note Due to debug fence sizes, the actual amount of usable memory can vary.
+            /// However, this is impossible to compute without knowing the exact allocation pattern before,
+            /// so this is just a rough estimate.
+            static constexpr std::size_t min_block_size(std::size_t byte_size) noexcept
+            {
+                return detail::memory_block_stack::implementation_offset() + byte_size;
+            }
+
+            /// \effects Creates it with a given initial block size and and other constructor arguments for the \concept{concept_blockallocator,BlockAllocator}.
+            /// It will allocate the first block and sets the top to its beginning.
+            /// \requires \c block_size must be at least \c min_block_size(1).
+            template <typename... Args>
+            explicit memory_stack(std::size_t block_size, Args&&... args)
+            : arena_(block_size, detail::forward<Args>(args)...),
+              stack_(arena_.allocate_block().memory)
+            {
+            }
+
+            /// \effects Allocates a memory block of given size and alignment.
+            /// It simply moves the top marker.
+            /// If there is not enough space on the current memory block,
+            /// a new one will be allocated by the \concept{concept_blockallocator,BlockAllocator} or taken from a cache
+            /// and used for the allocation.
+            /// \returns A \concept{concept_node,node} with given size and alignment.
+            /// \throws Anything thrown by the \concept{concept_blockallocator,BlockAllocator} on growth
+            /// or \ref bad_allocation_size if \c size is too big.
+            /// \requires \c size and \c alignment must be valid.
+            void* allocate(std::size_t size, std::size_t alignment)
+            {
+                auto fence  = detail::debug_fence_size;
+                auto offset = detail::align_offset(stack_.top() + fence, alignment);
+
+                if (!stack_.top()
+                    || fence + offset + size + fence > std::size_t(block_end() - stack_.top()))
+                {
+                    // need to grow
+                    auto block = arena_.allocate_block();
+                    stack_     = detail::fixed_memory_stack(block.memory);
+
+                    // new alignment required for over-aligned types
+                    offset = detail::align_offset(stack_.top() + fence, alignment);
+
+                    auto needed = fence + offset + size + fence;
+                    detail::check_allocation_size<bad_allocation_size>(needed, block.size, info());
+                }
+
+                return stack_.allocate_unchecked(size, offset);
+            }
+
+            /// \effects Allocates a memory block of given size and alignment,
+            /// similar to \ref allocate().
+            /// But it does not attempt a growth if the arena is empty.
+            /// \returns A \concept{concept_node,node} with given size and alignment
+            /// or `nullptr` if there wasn't enough memory available.
+            void* try_allocate(std::size_t size, std::size_t alignment) noexcept
+            {
+                return stack_.allocate(block_end(), size, alignment);
+            }
+
+            /// The marker type that is used for unwinding.
+            /// The exact type is implementation defined,
+            /// it is only required that it is efficiently copyable
+            /// and has all the comparision operators defined for two markers on the same stack.
+            /// Two markers are equal, if they are copies or created from two `top()` calls without a call to `unwind()` or `allocate()`.
+            /// A marker `a` is less than marker `b`, if after `a` was obtained, there was one or more call to `allocate()` and no call to `unwind()`.
+            using marker = WPI_IMPL_DEFINED(detail::stack_marker);
+
+            /// \returns A marker to the current top of the stack.
+            marker top() const noexcept
+            {
+                return {arena_.size() - 1, stack_, block_end()};
+            }
+
+            /// \effects Unwinds the stack to a certain marker position.
+            /// This sets the top pointer of the stack to the position described by the marker
+            /// and has the effect of deallocating all memory allocated since the marker was obtained.
+            /// If any memory blocks are unused after the operation,
+            /// they are not deallocated but put in a cache for later use,
+            /// call \ref shrink_to_fit() to actually deallocate them.
+            /// \requires The marker must point to memory that is still in use and was the whole time,
+            /// i.e. it must have been pointed below the top at all time.
+            void unwind(marker m) noexcept
+            {
+                WPI_MEMORY_ASSERT(m <= top());
+                detail::debug_check_pointer([&] { return m.index <= arena_.size() - 1; }, info(),
+                                            m.top);
+
+                if (std::size_t to_deallocate = (arena_.size() - 1) - m.index) // different index
+                {
+                    arena_.deallocate_block();
+                    for (std::size_t i = 1; i != to_deallocate; ++i)
+                        arena_.deallocate_block();
+
+                    detail::debug_check_pointer(
+                        [&] {
+                            auto cur = arena_.current_block();
+                            return m.end == static_cast<char*>(cur.memory) + cur.size;
+                        },
+                        info(), m.top);
+
+                    // mark memory from new top to end of the block as freed
+                    detail::debug_fill_free(m.top, std::size_t(m.end - m.top), 0);
+                    stack_ = detail::fixed_memory_stack(m.top);
+                }
+                else // same index
+                {
+                    detail::debug_check_pointer([&] { return stack_.top() >= m.top; }, info(),
+                                                m.top);
+                    stack_.unwind(m.top);
+                }
+            }
+
+            /// \effects \ref unwind() does not actually do any deallocation of blocks on the \concept{concept_blockallocator,BlockAllocator},
+            /// unused memory is stored in a cache for later reuse.
+            /// This function clears that cache.
+            void shrink_to_fit() noexcept
+            {
+                arena_.shrink_to_fit();
+            }
+
+            /// \returns The amount of memory remaining in the current block.
+            /// This is the number of bytes that are available for allocation
+            /// before the cache or \concept{concept_blockallocator,BlockAllocator} needs to be used.
+            std::size_t capacity_left() const noexcept
+            {
+                return std::size_t(block_end() - stack_.top());
+            }
+
+            /// \returns The size of the next memory block after the current block is exhausted and the arena grows.
+            /// This function just forwards to the \ref memory_arena.
+            /// \note All of it is available for the stack to use, but due to fences and alignment buffers,
+            /// this may not be the exact amount of memory usable for the user.
+            std::size_t next_capacity() const noexcept
+            {
+                return arena_.next_block_size();
+            }
+
+            /// \returns A reference to the \concept{concept_blockallocator,BlockAllocator} used for managing the arena.
+            /// \requires It is undefined behavior to move this allocator out into another object.
+            allocator_type& get_allocator() noexcept
+            {
+                return arena_.get_allocator();
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::memory_stack", this};
+            }
+
+            const char* block_end() const noexcept
+            {
+                auto block = arena_.current_block();
+                return static_cast<const char*>(block.memory) + block.size;
+            }
+
+            memory_arena<allocator_type> arena_;
+            detail::fixed_memory_stack   stack_;
+
+            friend allocator_traits<memory_stack<BlockOrRawAllocator>>;
+            friend composable_allocator_traits<memory_stack<BlockOrRawAllocator>>;
+        };
+
+        /// Simple utility that automatically unwinds a `Stack` to a previously saved location.
+        /// A `Stack` is anything that provides a `marker`, a `top()` function returning a `marker`
+        /// and an `unwind()` function to unwind to a `marker`,
+        /// like a \ref wpi::memory::memory_stack
+        /// \ingroup allocator
+        template <class Stack = memory_stack<>>
+        class memory_stack_raii_unwind
+        {
+        public:
+            using stack_type  = Stack;
+            using marker_type = typename stack_type::marker;
+
+            /// \effects Same as `memory_stack_raii_unwind(stack, stack.top())`.
+            explicit memory_stack_raii_unwind(stack_type& stack) noexcept
+            : memory_stack_raii_unwind(stack, stack.top())
+            {
+            }
+
+            /// \effects Creates the unwinder by giving it the stack and the marker.
+            /// \requires The stack must live longer than this object.
+            memory_stack_raii_unwind(stack_type& stack, marker_type marker) noexcept
+            : marker_(marker), stack_(&stack)
+            {
+            }
+
+            /// \effects Move constructs the unwinder by taking the saved position from `other`.
+            /// `other.will_unwind()` will return `false` after it.
+            memory_stack_raii_unwind(memory_stack_raii_unwind&& other) noexcept
+            : marker_(other.marker_), stack_(other.stack_)
+            {
+                other.stack_ = nullptr;
+            }
+
+            /// \effects Unwinds to the previously saved location,
+            /// if there is any, by calling `unwind()`.
+            ~memory_stack_raii_unwind() noexcept
+            {
+                if (stack_)
+                    stack_->unwind(marker_);
+            }
+
+            /// \effects Move assigns the unwinder by taking the saved position from `other`.
+            /// `other.will_unwind()` will return `false` after it.
+            memory_stack_raii_unwind& operator=(memory_stack_raii_unwind&& other) noexcept
+            {
+                if (stack_)
+                    stack_->unwind(marker_);
+
+                marker_ = other.marker_;
+                stack_  = other.stack_;
+
+                other.stack_ = nullptr;
+
+                return *this;
+            }
+
+            /// \effects Removes the location without unwinding it.
+            /// `will_unwind()` will return `false`.
+            void release() noexcept
+            {
+                stack_ = nullptr;
+            }
+
+            /// \effects Unwinds to the saved location explictly.
+            /// \requires `will_unwind()` must return `true`.
+            void unwind() noexcept
+            {
+                WPI_MEMORY_ASSERT(will_unwind());
+                stack_->unwind(marker_);
+            }
+
+            /// \returns Whether or not the unwinder will actually unwind.
+            /// \note It will not unwind if it is in the moved-from state.
+            bool will_unwind() const noexcept
+            {
+                return stack_ != nullptr;
+            }
+
+            /// \returns The saved marker, if there is any.
+            /// \requires `will_unwind()` must return `true`.
+            marker_type get_marker() const noexcept
+            {
+                WPI_MEMORY_ASSERT(will_unwind());
+                return marker_;
+            }
+
+            /// \returns The stack it will unwind.
+            /// \requires `will_unwind()` must return `true`.
+            stack_type& get_stack() const noexcept
+            {
+                WPI_MEMORY_ASSERT(will_unwind());
+                return *stack_;
+            }
+
+        private:
+            marker_type marker_;
+            stack_type* stack_;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class memory_stack<>;
+        extern template class memory_stack_raii_unwind<memory_stack<>>;
+#endif
+
+        /// Specialization of the \ref allocator_traits for \ref memory_stack classes.
+        /// \note It is not allowed to mix calls through the specialization and through the member functions,
+        /// i.e. \ref memory_stack::allocate() and this \c allocate_node().
+        /// \ingroup allocator
+        template <class BlockAllocator>
+        class allocator_traits<memory_stack<BlockAllocator>>
+        {
+        public:
+            using allocator_type = memory_stack<BlockAllocator>;
+            using is_stateful    = std::true_type;
+
+            /// \returns The result of \ref memory_stack::allocate().
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                auto mem = state.allocate(size, alignment);
+                state.on_allocate(size);
+                return mem;
+            }
+
+            /// \returns The result of \ref memory_stack::allocate().
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                return allocate_node(state, count * size, alignment);
+            }
+
+            /// @{
+            /// \effects Does nothing besides bookmarking for leak checking, if that is enabled.
+            /// Actual deallocation can only be done via \ref memory_stack::unwind().
+            static void deallocate_node(allocator_type& state, void*, std::size_t size,
+                                        std::size_t) noexcept
+            {
+                state.on_deallocate(size);
+            }
+
+            static void deallocate_array(allocator_type& state, void* ptr, std::size_t count,
+                                         std::size_t size, std::size_t alignment) noexcept
+            {
+                deallocate_node(state, ptr, count * size, alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \returns The maximum size which is \ref memory_stack::next_capacity().
+            static std::size_t max_node_size(const allocator_type& state) noexcept
+            {
+                return state.next_capacity();
+            }
+
+            static std::size_t max_array_size(const allocator_type& state) noexcept
+            {
+                return state.next_capacity();
+            }
+            /// @}
+
+            /// \returns The maximum possible value since there is no alignment restriction
+            /// (except indirectly through \ref memory_stack::next_capacity()).
+            static std::size_t max_alignment(const allocator_type&) noexcept
+            {
+                return std::size_t(-1);
+            }
+        };
+
+        /// Specialization of the \ref composable_allocator_traits for \ref memory_stack classes.
+        /// \ingroup allocator
+        template <class BlockAllocator>
+        class composable_allocator_traits<memory_stack<BlockAllocator>>
+        {
+        public:
+            using allocator_type = memory_stack<BlockAllocator>;
+
+            /// \returns The result of \ref memory_stack::try_allocate().
+            static void* try_allocate_node(allocator_type& state, std::size_t size,
+                                           std::size_t alignment) noexcept
+            {
+                return state.try_allocate(size, alignment);
+            }
+
+            /// \returns The result of \ref memory_stack::try_allocate().
+            static void* try_allocate_array(allocator_type& state, std::size_t count,
+                                            std::size_t size, std::size_t alignment) noexcept
+            {
+                return state.try_allocate(count * size, alignment);
+            }
+
+            /// @{
+            /// \effects Does nothing.
+            /// \returns Whether the memory will be deallocated by \ref memory_stack::unwind().
+            static bool try_deallocate_node(allocator_type& state, void* ptr, std::size_t,
+                                            std::size_t) noexcept
+            {
+                return state.arena_.owns(ptr);
+            }
+
+            static bool try_deallocate_array(allocator_type& state, void* ptr, std::size_t count,
+                                             std::size_t size, std::size_t alignment) noexcept
+            {
+                return try_deallocate_node(state, ptr, count * size, alignment);
+            }
+            /// @}
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<memory_stack<>>;
+        extern template class composable_allocator_traits<memory_stack<>>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_MEMORY_STACK_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/namespace_alias.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/namespace_alias.hpp
new file mode 100644
index 0000000..bf2b95d
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/namespace_alias.hpp
@@ -0,0 +1,37 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_NAMESPACE_ALIAS_HPP_INCLUDED
+#define WPI_MEMORY_NAMESPACE_ALIAS_HPP_INCLUDED
+
+/// \file
+/// Convenient namespace alias.
+
+/// \defgroup core Core components
+
+/// \defgroup allocator Allocator implementations
+
+/// \defgroup adapter Adapters and Wrappers
+
+/// \defgroup storage Allocator storage
+
+/// \namespace wpi
+/// Foonathan namespace.
+
+/// \namespace wpi::memory
+/// Memory namespace.
+
+/// \namespace wpi::memory::literals
+/// Literals namespace.
+
+namespace wpi
+{
+    namespace memory
+    {
+    }
+} // namespace wpi
+
+namespace memory = wpi::memory;
+
+#endif // WPI_MEMORY_NAMESPACE_ALIAS_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/new_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/new_allocator.hpp
new file mode 100644
index 0000000..8e24f2f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/new_allocator.hpp
@@ -0,0 +1,55 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_NEW_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_NEW_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::new_allocator.
+
+#include "detail/lowlevel_allocator.hpp"
+#include "config.hpp"
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+#include "allocator_traits.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        struct allocator_info;
+
+        namespace detail
+        {
+            struct new_allocator_impl
+            {
+                static allocator_info info() noexcept;
+
+                static void* allocate(std::size_t size, std::size_t) noexcept;
+
+                static void deallocate(void* ptr, std::size_t size, std::size_t) noexcept;
+
+                static std::size_t max_node_size() noexcept;
+            };
+
+            WPI_MEMORY_LL_ALLOCATOR_LEAK_CHECKER(new_allocator_impl,
+                                                       new_alloator_leak_checker)
+        } // namespace detail
+
+        /// A stateless \concept{concept_rawallocator,RawAllocator} that allocates memory using (nothrow) <tt>operator new</tt>.
+        /// If the operator returns \c nullptr, it behaves like \c new and loops calling \c std::new_handler,
+        /// but instead of throwing a \c std::bad_alloc exception, it throws \ref out_of_memory.
+        /// \ingroup allocator
+        using new_allocator =
+            WPI_IMPL_DEFINED(detail::lowlevel_allocator<detail::new_allocator_impl>);
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class detail::lowlevel_allocator<detail::new_allocator_impl>;
+        extern template class allocator_traits<new_allocator>;
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_NEW_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/segregator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/segregator.hpp
new file mode 100644
index 0000000..fcd02ac
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/segregator.hpp
@@ -0,0 +1,448 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_SEGREGATOR_HPP_INCLUDED
+#define WPI_MEMORY_SEGREGATOR_HPP_INCLUDED
+
+/// \file
+/// Class template \ref wpi::memory::segregator and related classes.
+
+#include "detail/ebo_storage.hpp"
+#include "detail/utility.hpp"
+#include "allocator_traits.hpp"
+#include "config.hpp"
+#include "error.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A \concept{concept_segregatable,Segregatable} that allocates until a maximum size.
+        /// \ingroup adapter
+        template <class RawAllocator>
+        class threshold_segregatable : WPI_EBO(allocator_traits<RawAllocator>::allocator_type)
+        {
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+
+            /// \effects Creates it by passing the maximum size it will allocate
+            /// and the allocator it uses.
+            explicit threshold_segregatable(std::size_t    max_size,
+                                            allocator_type alloc = allocator_type())
+            : allocator_type(detail::move(alloc)), max_size_(max_size)
+            {
+            }
+
+            /// \returns `true` if `size` is less then or equal to the maximum size,
+            /// `false` otherwise.
+            /// \note A return value of `true` means that the allocator will be used for the allocation.
+            bool use_allocate_node(std::size_t size, std::size_t) noexcept
+            {
+                return size <= max_size_;
+            }
+
+            /// \returns `true` if `count * size` is less then or equal to the maximum size,
+            /// `false` otherwise.
+            /// \note A return value of `true` means that the allocator will be used for the allocation.
+            bool use_allocate_array(std::size_t count, std::size_t size, std::size_t) noexcept
+            {
+                return count * size <= max_size_;
+            }
+
+            /// @{
+            /// \returns A reference to the allocator it owns.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+        private:
+            std::size_t max_size_;
+        };
+
+        /// \returns A \ref threshold_segregatable with the same parameter.
+        template <class RawAllocator>
+        threshold_segregatable<typename std::decay<RawAllocator>::type> threshold(
+            std::size_t max_size, RawAllocator&& alloc)
+        {
+            return threshold_segregatable<
+                typename std::decay<RawAllocator>::type>(max_size,
+                                                         std::forward<RawAllocator>(alloc));
+        }
+
+        /// A composable \concept{concept_rawallocator,RawAllocator} that will always fail.
+        /// This is useful for compositioning or as last resort in \ref binary_segregator.
+        /// \ingroup allocator
+        class null_allocator
+        {
+        public:
+            /// \effects Will always throw.
+            /// \throws A \ref out_of_fixed_memory exception.
+            void* allocate_node(std::size_t size, std::size_t)
+            {
+                throw out_of_fixed_memory(info(), size);
+            }
+
+            /// \requires Must not be called.
+            void deallocate_node(void*, std::size_t, std::size_t) noexcept
+            {
+                WPI_MEMORY_UNREACHABLE("cannot be called with proper values");
+            }
+
+            /// \effects Does nothing.
+            /// \returns Always returns `nullptr`.
+            void* try_allocate_node(std::size_t, std::size_t) noexcept
+            {
+                return nullptr;
+            }
+
+            /// \effects Does nothing.
+            /// \returns Always returns `false`.
+            bool try_deallocate_node(void*, std::size_t, std::size_t) noexcept
+            {
+                return false;
+            }
+
+        private:
+            allocator_info info() const noexcept
+            {
+                return {WPI_MEMORY_LOG_PREFIX "::null_allocator", this};
+            }
+        };
+
+        /// A \concept{concept_rawallocator,RawAllocator} that either uses the \concept{concept_segregatable,Segregatable} or the other `RawAllocator`.
+        /// It is a faster alternative to \ref fallback_allocator that doesn't require a composable allocator
+        /// and decides about the allocator to use purely with the `Segregatable` based on size and alignment.
+        /// \ingroup adapter
+        template <class Segregatable, class RawAllocator>
+        class binary_segregator
+        : WPI_EBO(
+              detail::ebo_storage<1, typename allocator_traits<RawAllocator>::allocator_type>)
+        {
+            using segregatable_traits = allocator_traits<typename Segregatable::allocator_type>;
+            using fallback_traits     = allocator_traits<RawAllocator>;
+
+        public:
+            using segregatable                = Segregatable;
+            using segregatable_allocator_type = typename segregatable::allocator_type;
+            using fallback_allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+
+            /// \effects Creates it by giving the \concept{concept_segregatable,Segregatable}
+            /// and the \concept{concept_rawallocator,RawAllocator}.
+            explicit binary_segregator(segregatable            s,
+                                       fallback_allocator_type fallback = fallback_allocator_type())
+            : detail::ebo_storage<1, fallback_allocator_type>(detail::move(fallback)),
+              s_(detail::move(s))
+            {
+            }
+
+            /// @{
+            /// \effects Uses the \concept{concept_segregatable,Segregatable} to decide which allocator to use.
+            /// Then forwards to the chosen allocator.
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                if (get_segregatable().use_allocate_node(size, alignment))
+                    return segregatable_traits::allocate_node(get_segregatable_allocator(), size,
+                                                              alignment);
+                else
+                    return fallback_traits::allocate_node(get_fallback_allocator(), size,
+                                                          alignment);
+            }
+
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                if (get_segregatable().use_allocate_node(size, alignment))
+                    segregatable_traits::deallocate_node(get_segregatable_allocator(), ptr, size,
+                                                         alignment);
+                else
+                    fallback_traits::deallocate_node(get_fallback_allocator(), ptr, size,
+                                                     alignment);
+            }
+
+            void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+            {
+                if (get_segregatable().use_allocate_array(count, size, alignment))
+                    return segregatable_traits::allocate_array(get_segregatable_allocator(), count,
+                                                               size, alignment);
+                else
+                    return fallback_traits::allocate_array(get_fallback_allocator(), count, size,
+                                                           alignment);
+            }
+
+            void deallocate_array(void* array, std::size_t count, std::size_t size,
+                                  std::size_t alignment) noexcept
+            {
+                if (get_segregatable().use_allocate_array(count, size, alignment))
+                    segregatable_traits::deallocate_array(get_segregatable_allocator(), array,
+                                                          count, size, alignment);
+                else
+                    fallback_traits::deallocate_array(get_fallback_allocator(), array, count, size,
+                                                      alignment);
+            }
+            /// @}
+
+            /// @{
+            /// \returns The maximum value of the fallback.
+            /// \note It assumes that the fallback will be used for larger allocations,
+            /// and the `Segregatable` for smaller ones.
+            std::size_t max_node_size() const
+            {
+                return fallback_traits::max_node_size(get_fallback_allocator());
+            }
+
+            std::size_t max_array_size() const
+            {
+                return fallback_traits::max_array_size(get_fallback_allocator());
+            }
+
+            std::size_t max_alignemnt() const
+            {
+                return fallback_traits::max_alignment(get_fallback_allocator());
+            }
+            /// @}
+
+            /// @{
+            /// \returns A reference to the segregatable allocator.
+            /// This is the one primarily used.
+            segregatable_allocator_type& get_segregatable_allocator() noexcept
+            {
+                return get_segregatable().get_allocator();
+            }
+
+            const segregatable_allocator_type& get_segregatable_allocator() const noexcept
+            {
+                return get_segregatable().get_allocator();
+            }
+            /// @}
+
+            /// @{
+            /// \returns A reference to the fallback allocator.
+            /// It will be used if the \concept{concept_segregator,Segregator} doesn't want the alloction.
+            fallback_allocator_type& get_fallback_allocator() noexcept
+            {
+                return detail::ebo_storage<1, fallback_allocator_type>::get();
+            }
+
+            const fallback_allocator_type& get_fallback_allocator() const noexcept
+            {
+                return detail::ebo_storage<1, fallback_allocator_type>::get();
+            }
+            /// @}
+
+        private:
+            segregatable& get_segregatable() noexcept
+            {
+                return s_;
+            }
+
+            segregatable s_;
+        };
+
+        namespace detail
+        {
+            template <class... Segregatables>
+            struct make_segregator_t;
+
+            template <class Segregatable>
+            struct make_segregator_t<Segregatable>
+            {
+                using type = binary_segregator<Segregatable, null_allocator>;
+            };
+
+            template <class Segregatable, class RawAllocator>
+            struct make_segregator_t<Segregatable, RawAllocator>
+            {
+                using type = binary_segregator<Segregatable, RawAllocator>;
+            };
+
+            template <class Segregatable, class... Tail>
+            struct make_segregator_t<Segregatable, Tail...>
+            {
+                using type =
+                    binary_segregator<Segregatable, typename make_segregator_t<Tail...>::type>;
+            };
+
+            template <class Segregator, class Fallback = null_allocator>
+            auto make_segregator(Segregator&& seg, Fallback&& f = null_allocator{})
+                -> binary_segregator<typename std::decay<Segregator>::type,
+                                     typename std::decay<Fallback>::type>
+            {
+                return binary_segregator<
+                    typename std::decay<Segregator>::type,
+                    typename std::decay<Fallback>::type>(std::forward<Segregator>(seg),
+                                                         std::forward<Fallback>(f));
+            }
+
+            template <class Segregator, typename... Rest>
+            auto make_segregator(Segregator&& seg, Rest&&... rest)
+                -> binary_segregator<typename std::decay<Segregator>::type,
+                                     decltype(make_segregator(std::forward<Rest>(rest)...))>
+            {
+                return binary_segregator<typename std::decay<Segregator>::type,
+                                         decltype(make_segregator(std::forward<Rest>(
+                                             rest)...))>(std::forward<Segregator>(seg),
+                                                         make_segregator(
+                                                             std::forward<Rest>(rest)...));
+            }
+
+            template <std::size_t I, class Segregator>
+            struct segregatable_type;
+
+            template <class Segregator, class Fallback>
+            struct segregatable_type<0, binary_segregator<Segregator, Fallback>>
+            {
+                using type = typename Segregator::allocator_type;
+
+                static type& get(binary_segregator<Segregator, Fallback>& s)
+                {
+                    return s.get_segregatable_allocator();
+                }
+
+                static const type& get(const binary_segregator<Segregator, Fallback>& s)
+                {
+                    return s.get_segregatable_allocator();
+                }
+            };
+
+            template <std::size_t I, class Segregator, class Fallback>
+            struct segregatable_type<I, binary_segregator<Segregator, Fallback>>
+            {
+                using base = segregatable_type<I - 1, Fallback>;
+                using type = typename base::type;
+
+                static type& get(binary_segregator<Segregator, Fallback>& s)
+                {
+                    return base::get(s.get_fallback_allocator());
+                }
+
+                static const type& get(const binary_segregator<Segregator, Fallback>& s)
+                {
+                    return base::get(s.get_fallback_allocator());
+                }
+            };
+
+            template <class Fallback>
+            struct fallback_type
+            {
+                using type = Fallback;
+
+                static const std::size_t size = 0u;
+
+                static type& get(Fallback& f)
+                {
+                    return f;
+                }
+
+                static const type& get(const Fallback& f)
+                {
+                    return f;
+                }
+            };
+
+            template <class Segregator, class Fallback>
+            struct fallback_type<binary_segregator<Segregator, Fallback>>
+            {
+                using base = fallback_type<Fallback>;
+                using type = typename base::type;
+
+                static const std::size_t size = base::size + 1u;
+
+                static type& get(binary_segregator<Segregator, Fallback>& s)
+                {
+                    return base::get(s.get_fallback_allocator());
+                }
+
+                static const type& get(const binary_segregator<Segregator, Fallback>& s)
+                {
+                    return base::get(s.get_fallback_allocator());
+                }
+            };
+        } // namespace detail
+
+        /// Creates multiple nested \ref binary_segregator.
+        /// If you pass one type, it must be a \concept{concept_segregatable,Segregatable}.
+        /// Then the result is a \ref binary_segregator with that `Segregatable` and \ref null_allocator as fallback.
+        /// If you pass two types, the first one must be a `Segregatable`,
+        /// the second one a \concept{concept_rawallocator,RawAllocator}.
+        /// Then the result is a simple \ref binary_segregator with those arguments.
+        /// If you pass more than one, the last one must be a `RawAllocator` all others `Segregatable`,
+        /// the result is `binary_segregator<Head, segregator<Tail...>>`.
+        /// \note It will result in an allocator that tries each `Segregatable` in the order specified
+        /// using the last parameter as final fallback.
+        /// \ingroup adapter
+        template <class... Allocators>
+        WPI_ALIAS_TEMPLATE(segregator,
+                                 typename detail::make_segregator_t<Allocators...>::type);
+
+        /// \returns A \ref segregator created from the allocators `args`.
+        /// \relates segregator
+        template <typename... Args>
+        auto make_segregator(Args&&... args) -> segregator<typename std::decay<Args>::type...>
+        {
+            return detail::make_segregator(std::forward<Args>(args)...);
+        }
+
+        /// The number of \concept{concept_segregatable,Segregatable} a \ref segregator has.
+        /// \relates segregator
+        template <class Segregator>
+        struct segregator_size
+        {
+            static const std::size_t value = detail::fallback_type<Segregator>::size;
+        };
+
+        /// The type of the `I`th \concept{concept_segregatable,Segregatable}.
+        /// \relates segregator
+        template <std::size_t I, class Segregator>
+        using segregatable_allocator_type = typename detail::segregatable_type<I, Segregator>::type;
+
+        /// @{
+        /// \returns The `I`th \concept{concept_segregatable,Segregatable}.
+        /// \relates segregrator
+        template <std::size_t I, class Segregator, class Fallback>
+        auto get_segregatable_allocator(binary_segregator<Segregator, Fallback>& s)
+            -> segregatable_allocator_type<I, binary_segregator<Segregator, Fallback>>&
+        {
+            return detail::segregatable_type<I, binary_segregator<Segregator, Fallback>>::get(s);
+        }
+
+        template <std::size_t I, class Segregator, class Fallback>
+        auto get_segregatable_allocator(const binary_segregator<Segregator, Fallback>& s)
+            -> const segregatable_allocator_type<I, binary_segregator<Segregator, Fallback>>
+        {
+            return detail::segregatable_type<I, binary_segregator<Segregator, Fallback>>::get(s);
+        }
+        /// @}
+
+        /// The type of the final fallback \concept{concept_rawallocator,RawAllocator}.
+        /// \relates segregator
+        template <class Segregator>
+        using fallback_allocator_type = typename detail::fallback_type<Segregator>::type;
+
+        /// @{
+        /// \returns The final fallback \concept{concept_rawallocator,RawAllocator}.
+        /// \relates segregator
+        template <class Segregator, class Fallback>
+        auto get_fallback_allocator(binary_segregator<Segregator, Fallback>& s)
+            -> fallback_allocator_type<binary_segregator<Segregator, Fallback>>&
+        {
+            return detail::fallback_type<binary_segregator<Segregator, Fallback>>::get(s);
+        }
+
+        template <class Segregator, class Fallback>
+        auto get_fallback_allocator(const binary_segregator<Segregator, Fallback>& s)
+            -> const fallback_allocator_type<binary_segregator<Segregator, Fallback>>&
+        {
+            return detail::fallback_type<binary_segregator<Segregator, Fallback>>::get(s);
+        }
+        /// @}
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_SEGREGATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/smart_ptr.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/smart_ptr.hpp
new file mode 100644
index 0000000..877efd7
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/smart_ptr.hpp
@@ -0,0 +1,210 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_SMART_PTR_HPP_INCLUDED
+#define WPI_MEMORY_SMART_PTR_HPP_INCLUDED
+
+/// \file
+/// \c std::make_unique() / \c std::make_shared() replacement allocating memory through a \concept{concept_rawallocator,RawAllocator}.
+/// \note Only available on a hosted implementation.
+
+#include "config.hpp"
+#if !WPI_HOSTED_IMPLEMENTATION
+#error "This header is only available for a hosted implementation."
+#endif
+
+#include <memory>
+#include <type_traits>
+
+#include "detail/utility.hpp"
+#include "deleter.hpp"
+#include "std_allocator.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <typename T, class RawAllocator, typename... Args>
+            auto allocate_unique(allocator_reference<RawAllocator> alloc, Args&&... args)
+                -> std::unique_ptr<T, allocator_deleter<T, RawAllocator>>
+            {
+                using raw_ptr = std::unique_ptr<T, allocator_deallocator<T, RawAllocator>>;
+
+                auto memory = alloc.allocate_node(sizeof(T), alignof(T));
+                // raw_ptr deallocates memory in case of constructor exception
+                raw_ptr result(static_cast<T*>(memory), {alloc});
+                // call constructor
+                ::new (memory) T(detail::forward<Args>(args)...);
+                // pass ownership to return value using a deleter that calls destructor
+                return {result.release(), {alloc}};
+            }
+
+            template <typename T, typename... Args>
+            void construct(std::true_type, T* cur, T* end, Args&&... args)
+            {
+                for (; cur != end; ++cur)
+                    ::new (static_cast<void*>(cur)) T(detail::forward<Args>(args)...);
+            }
+
+            template <typename T, typename... Args>
+            void construct(std::false_type, T* begin, T* end, Args&&... args)
+            {
+#if WPI_HAS_EXCEPTION_SUPPORT
+                auto cur = begin;
+                try
+                {
+                    for (; cur != end; ++cur)
+                        ::new (static_cast<void*>(cur)) T(detail::forward<Args>(args)...);
+                }
+                catch (...)
+                {
+                    for (auto el = begin; el != cur; ++el)
+                        el->~T();
+                    throw;
+                }
+#else
+                construct(std::true_type{}, begin, end, detail::forward<Args>(args)...);
+#endif
+            }
+
+            template <typename T, class RawAllocator>
+            auto allocate_array_unique(std::size_t size, allocator_reference<RawAllocator> alloc)
+                -> std::unique_ptr<T[], allocator_deleter<T[], RawAllocator>>
+            {
+                using raw_ptr = std::unique_ptr<T[], allocator_deallocator<T[], RawAllocator>>;
+
+                auto memory = alloc.allocate_array(size, sizeof(T), alignof(T));
+                // raw_ptr deallocates memory in case of constructor exception
+                raw_ptr result(static_cast<T*>(memory), {alloc, size});
+                construct(std::integral_constant<bool, noexcept(T())>{}, result.get(),
+                          result.get() + size);
+                // pass ownership to return value using a deleter that calls destructor
+                return {result.release(), {alloc, size}};
+            }
+        } // namespace detail
+
+        /// A \c std::unique_ptr that deletes using a \concept{concept_rawallocator,RawAllocator}.
+        ///
+        /// It is an alias template using \ref allocator_deleter as \c Deleter class.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(unique_ptr,
+                                 std::unique_ptr<T, allocator_deleter<T, RawAllocator>>);
+
+        /// A \c std::unique_ptr that deletes using a \concept{concept_rawallocator,RawAllocator} and allows polymorphic types.
+        ///
+        /// It can only be created by converting a regular unique pointer to a pointer to a derived class,
+        /// and is meant to be used inside containers.
+        /// It is an alias template using \ref allocator_polymorphic_deleter as \c Deleter class.
+        /// \note It has a relatively high overhead, so only use it if you have to.
+        /// \ingroup adapter
+        template <class BaseType, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            unique_base_ptr,
+            std::unique_ptr<BaseType, allocator_polymorphic_deleter<BaseType, RawAllocator>>);
+
+        /// Creates a \c std::unique_ptr using a \concept{concept_rawallocator,RawAllocator} for the allocation.
+        /// \effects Allocates memory for the given type using the allocator
+        /// and creates a new object inside it passing the given arguments to its constructor.
+        /// \returns A \c std::unique_ptr owning that memory.
+        /// \note If the allocator is stateful a reference to the \c RawAllocator will be stored inside the deleter,
+        /// the caller has to ensure that the object lives as long as the smart pointer.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator, typename... Args>
+        auto allocate_unique(RawAllocator&& alloc, Args&&... args) -> WPI_REQUIRES_RET(
+            !std::is_array<T>::value,
+            std::unique_ptr<T, allocator_deleter<T, typename std::decay<RawAllocator>::type>>)
+        {
+            return detail::allocate_unique<T>(make_allocator_reference(
+                                                  detail::forward<RawAllocator>(alloc)),
+                                              detail::forward<Args>(args)...);
+        }
+
+        /// Creates a \c std::unique_ptr using a type-erased \concept{concept_rawallocator,RawAllocator} for the allocation.
+        /// It is the same as the other overload but stores the reference to the allocator type-erased inside the \c std::unique_ptr.
+        /// \effects Allocates memory for the given type using the allocator
+        /// and creates a new object inside it passing the given arguments to its constructor.
+        /// \returns A \c std::unique_ptr with a type-erased allocator reference owning that memory.
+        /// \note If the allocator is stateful a reference to the \c RawAllocator will be stored inside the deleter,
+        /// the caller has to ensure that the object lives as long as the smart pointer.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator, typename... Args>
+        auto allocate_unique(any_allocator, RawAllocator&& alloc, Args&&... args)
+            -> WPI_REQUIRES_RET(!std::is_array<T>::value,
+                                      std::unique_ptr<T, allocator_deleter<T, any_allocator>>)
+        {
+            return detail::allocate_unique<T, any_allocator>(make_allocator_reference(
+                                                                 detail::forward<RawAllocator>(
+                                                                     alloc)),
+                                                             detail::forward<Args>(args)...);
+        }
+
+        /// Creates a \c std::unique_ptr owning an array using a \concept{concept_rawallocator,RawAllocator} for the allocation.
+        /// \effects Allocates memory for an array of given size and value initializes each element inside of it.
+        /// \returns A \c std::unique_ptr owning that array.
+        /// \note If the allocator is stateful a reference to the \c RawAllocator will be stored inside the deleter,
+        /// the caller has to ensure that the object lives as long as the smart pointer.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator>
+        auto allocate_unique(RawAllocator&& alloc, std::size_t size) -> WPI_REQUIRES_RET(
+            std::is_array<T>::value,
+            std::unique_ptr<T, allocator_deleter<T, typename std::decay<RawAllocator>::type>>)
+        {
+            return detail::allocate_array_unique<
+                typename std::remove_extent<T>::type>(size,
+                                                      make_allocator_reference(
+                                                          detail::forward<RawAllocator>(alloc)));
+        }
+
+        /// Creates a \c std::unique_ptr owning an array using a type-erased \concept{concept_rawallocator,RawAllocator} for the allocation.
+        /// It is the same as the other overload but stores the reference to the allocator type-erased inside the \c std::unique_ptr.
+        /// \effects Allocates memory for an array of given size and value initializes each element inside of it.
+        /// \returns A \c std::unique_ptr with a type-erased allocator reference owning that array.
+        /// \note If the allocator is stateful a reference to the \c RawAllocator will be stored inside the deleter,
+        /// the caller has to ensure that the object lives as long as the smart pointer.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator>
+        auto allocate_unique(any_allocator, RawAllocator&& alloc, std::size_t size)
+            -> WPI_REQUIRES_RET(std::is_array<T>::value,
+                                      std::unique_ptr<T, allocator_deleter<T, any_allocator>>)
+        {
+            return detail::allocate_array_unique<typename std::remove_extent<T>::type,
+                                                 any_allocator>(size,
+                                                                make_allocator_reference(
+                                                                    detail::forward<RawAllocator>(
+                                                                        alloc)));
+        }
+
+        /// Creates a \c std::shared_ptr using a \concept{concept_rawallocator,RawAllocator} for the allocation.
+        /// It is similar to \c std::allocate_shared but uses a \c RawAllocator (and thus also supports any \c Allocator).
+        /// \effects Calls \ref std_allocator::make_std_allocator to wrap the allocator and forwards to \c std::allocate_shared.
+        /// \returns A \c std::shared_ptr created using \c std::allocate_shared.
+        /// \note If the allocator is stateful a reference to the \c RawAllocator will be stored inside the shared pointer,
+        /// the caller has to ensure that the object lives as long as the smart pointer.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator, typename... Args>
+        std::shared_ptr<T> allocate_shared(RawAllocator&& alloc, Args&&... args)
+        {
+            return std::allocate_shared<T>(make_std_allocator<T>(
+                                               detail::forward<RawAllocator>(alloc)),
+                                           detail::forward<Args>(args)...);
+        }
+
+#if !defined(DOXYGEN)
+#include "detail/container_node_sizes.hpp"
+#else
+        /// Contains the node size needed for a `std::shared_ptr`.
+        /// These classes are auto-generated and only available if the tools are build and without cross-compiling.
+        /// \ingroup adapter
+        template <typename T>
+        struct shared_ptr_node_size : std::integral_constant<std::size_t, implementation_defined>
+        {
+        };
+#endif
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_SMART_PTR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/static_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/static_allocator.hpp
new file mode 100644
index 0000000..efbbf73
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/static_allocator.hpp
@@ -0,0 +1,179 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_STATIC_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_STATIC_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Allocators using a static, fixed-sized storage.
+
+#include <type_traits>
+
+#include "detail/align.hpp"
+#include "detail/assert.hpp"
+#include "detail/memory_stack.hpp"
+#include "detail/utility.hpp"
+#include "config.hpp"
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+#include "allocator_traits.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// Storage for a \ref static_allocator.
+        /// Its constructor will take a reference to it and use it for its allocation.
+        /// The storage type is simply a \c char array aligned for maximum alignment.
+        /// \note It is not allowed to access the memory of the storage.
+        /// \ingroup allocator
+        template <std::size_t Size>
+        struct static_allocator_storage
+        {
+            alignas(detail::max_alignment) char storage[Size];
+        };
+
+        static_assert(sizeof(static_allocator_storage<1024>) == 1024, "");
+        static_assert(alignof(static_allocator_storage<1024>) == detail::max_alignment, "");
+
+        struct allocator_info;
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that uses a fixed sized storage for the allocations.
+        /// It works on a \ref static_allocator_storage and uses its memory for all allocations.
+        /// Deallocations are not supported, memory cannot be marked as freed.<br>
+        /// \note It is not allowed to share an \ref static_allocator_storage between multiple \ref static_allocator objects.
+        /// \ingroup allocator
+        class static_allocator
+        {
+        public:
+            using is_stateful = std::true_type;
+
+            /// \effects Creates it by passing it a \ref static_allocator_storage by reference.
+            /// It will take the address of the storage and use its memory for the allocation.
+            /// \requires The storage object must live as long as the allocator object.
+            /// It must not be shared between multiple allocators,
+            /// i.e. the object must not have been passed to a constructor before.
+            template <std::size_t Size>
+            static_allocator(static_allocator_storage<Size>& storage) noexcept
+            : stack_(&storage), end_(stack_.top() + Size)
+            {
+            }
+
+            /// \effects A \concept{concept_rawallocator,RawAllocator} allocation function.
+            /// It uses the specified \ref static_allocator_storage.
+            /// \returns A pointer to a \concept{concept_node,node}, it will never be \c nullptr.
+            /// \throws An exception of type \ref out_of_memory or whatever is thrown by its handler if the storage is exhausted.
+            void* allocate_node(std::size_t size, std::size_t alignment);
+
+            /// \effects A \concept{concept_rawallocator,RawAllocator} deallocation function.
+            /// It does nothing, deallocation is not supported by this allocator.
+            void deallocate_node(void*, std::size_t, std::size_t) noexcept {}
+
+            /// \returns The maximum node size which is the capacity remaining inside the \ref static_allocator_storage.
+            std::size_t max_node_size() const noexcept
+            {
+                return static_cast<std::size_t>(end_ - stack_.top());
+            }
+
+            /// \returns The maximum possible value since there is no alignment restriction
+            /// (except indirectly through the size of the \ref static_allocator_storage).
+            std::size_t max_alignment() const noexcept
+            {
+                return std::size_t(-1);
+            }
+
+        private:
+            allocator_info info() const noexcept;
+
+            detail::fixed_memory_stack stack_;
+            const char*                end_;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<static_allocator>;
+#endif
+
+        struct memory_block;
+
+        /// A \concept{concept_blockallocator,BlockAllocator} that allocates the blocks from a fixed size storage.
+        /// It works on a \ref static_allocator_storage and uses it for all allocations,
+        /// deallocations are only allowed in reversed order which is guaranteed by \ref memory_arena.
+        /// \note It is not allowed to share an \ref static_allocator_storage between multiple \ref static_allocator objects.
+        /// \ingroup allocator
+        class static_block_allocator
+        {
+        public:
+            /// \effects Creates it by passing it the block size and a \ref static_allocator_storage by reference.
+            /// It will take the address of the storage and use it to allocate \c block_size'd blocks.
+            /// \requires The storage object must live as long as the allocator object.
+            /// It must not be shared between multiple allocators,
+            /// i.e. the object must not have been passed to a constructor before.
+            /// The size of the \ref static_allocator_storage must be a multiple of the (non-null) block size.
+            template <std::size_t Size>
+            static_block_allocator(std::size_t                     block_size,
+                                   static_allocator_storage<Size>& storage) noexcept
+            : cur_(static_cast<char*>(static_cast<void*>(&storage))),
+              end_(cur_ + Size),
+              block_size_(block_size)
+            {
+                WPI_MEMORY_ASSERT(block_size <= Size);
+                WPI_MEMORY_ASSERT(Size % block_size == 0u);
+            }
+
+            ~static_block_allocator() noexcept = default;
+
+            /// @{
+            /// \effects Moves the block allocator, it transfers ownership over the \ref static_allocator_storage.
+            /// This does not invalidate any memory blocks.
+            static_block_allocator(static_block_allocator&& other) noexcept
+            : cur_(other.cur_), end_(other.end_), block_size_(other.block_size_)
+            {
+                other.cur_ = other.end_ = nullptr;
+                other.block_size_       = 0;
+            }
+
+            static_block_allocator& operator=(static_block_allocator&& other) noexcept
+            {
+                static_block_allocator tmp(detail::move(other));
+                swap(*this, tmp);
+                return *this;
+            }
+            /// @}
+
+            /// \effects Swaps the ownership over the \ref static_allocator_storage.
+            /// This does not invalidate any memory blocks.
+            friend void swap(static_block_allocator& a, static_block_allocator& b) noexcept
+            {
+                detail::adl_swap(a.cur_, b.cur_);
+                detail::adl_swap(a.end_, b.end_);
+                detail::adl_swap(a.block_size_, b.block_size_);
+            }
+
+            /// \effects Allocates a new block by returning the \ref next_block_size() bytes.
+            /// \returns The new memory block.
+            memory_block allocate_block();
+
+            /// \effects Deallocates the last memory block by marking the block as free again.
+            /// This block will be returned again by the next call to \ref allocate_block().
+            /// \requires \c block must be the current top block of the memory,
+            /// this is guaranteed by \ref memory_arena.
+            void deallocate_block(memory_block block) noexcept;
+
+            /// \returns The next block size, this is the size passed to the constructor.
+            std::size_t next_block_size() const noexcept
+            {
+                return block_size_;
+            }
+
+        private:
+            allocator_info info() const noexcept;
+
+            char *      cur_, *end_;
+            std::size_t block_size_;
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_STATIC_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/std_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/std_allocator.hpp
new file mode 100644
index 0000000..f727a1c
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/std_allocator.hpp
@@ -0,0 +1,360 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_STD_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_STD_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::std_allocator and related classes and functions.
+
+#include <new>
+#include <type_traits>
+
+#include "detail/utility.hpp"
+#include "config.hpp"
+#include "allocator_storage.hpp"
+#include "threading.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace traits_detail
+        {
+            template <class RawAllocator>
+            auto propagate_on_container_swap(std_concept) ->
+                typename RawAllocator::propagate_on_container_swap;
+
+            template <class RawAllocator>
+            auto propagate_on_container_swap(min_concept) -> std::true_type;
+
+            template <class RawAllocator>
+            auto propagate_on_container_move_assignment(std_concept) ->
+                typename RawAllocator::propagate_on_container_move_assignment;
+
+            template <class RawAllocator>
+            auto propagate_on_container_move_assignment(min_concept) -> std::true_type;
+
+            template <class RawAllocator>
+            auto propagate_on_container_copy_assignment(std_concept) ->
+                typename RawAllocator::propagate_on_container_copy_assignment;
+
+            template <class RawAllocator>
+            auto propagate_on_container_copy_assignment(min_concept) -> std::true_type;
+        } // namespace traits_detail
+
+        /// Controls the propagation of a \ref std_allocator for a certain \concept{concept_rawallocator,RawAllocator}.
+        /// \ingroup adapter
+        template <class RawAllocator>
+        struct propagation_traits
+        {
+            using propagate_on_container_swap =
+                decltype(traits_detail::propagate_on_container_swap<RawAllocator>(
+                    traits_detail::full_concept{}));
+
+            using propagate_on_container_move_assignment =
+                decltype(traits_detail::propagate_on_container_move_assignment<RawAllocator>(
+                    traits_detail::full_concept{}));
+
+            using propagate_on_container_copy_assignment =
+                decltype(traits_detail::propagate_on_container_copy_assignment<RawAllocator>(
+                    traits_detail::full_concept{}));
+
+            template <class AllocReference>
+            static AllocReference select_on_container_copy_construction(const AllocReference& alloc)
+            {
+                return alloc;
+            }
+        };
+
+        /// Wraps a \concept{concept_rawallocator,RawAllocator} and makes it a "normal" \c Allocator.
+        /// It allows using a \c RawAllocator anywhere a \c Allocator is required.
+        /// \ingroup adapter
+        template <typename T, class RawAllocator>
+        class std_allocator :
+#if defined _MSC_VER && defined __clang__
+            WPI_EBO(protected allocator_reference<RawAllocator>)
+#else
+            WPI_EBO(allocator_reference<RawAllocator>)
+#endif
+        {
+            using alloc_reference = allocator_reference<RawAllocator>;
+            // if it is any_allocator_reference an optimized implementation can be used
+            using is_any = std::is_same<alloc_reference, any_allocator_reference>;
+
+            using prop_traits = propagation_traits<RawAllocator>;
+
+        public:
+            //=== typedefs ===//
+            using value_type      = T;
+            using pointer         = T*;
+            using const_pointer   = const T*;
+            using reference       = T&;
+            using const_reference = const T&;
+            using size_type       = std::size_t;
+            using difference_type = std::ptrdiff_t;
+
+            using propagate_on_container_swap = typename prop_traits::propagate_on_container_swap;
+            using propagate_on_container_move_assignment =
+                typename prop_traits::propagate_on_container_move_assignment;
+            using propagate_on_container_copy_assignment =
+                typename prop_traits::propagate_on_container_copy_assignment;
+
+            template <typename U>
+            struct rebind
+            {
+                using other = std_allocator<U, RawAllocator>;
+            };
+
+            using allocator_type = typename alloc_reference::allocator_type;
+
+            //=== constructor ===//
+            /// \effects Default constructs it by storing a default constructed, stateless \c RawAllocator inside the reference.
+            /// \requires The \c RawAllocator type is stateless, otherwise the body of this function will not compile.
+            std_allocator() noexcept : alloc_reference(allocator_type{})
+            {
+#if !defined(__GNUC__) || (defined(_GLIBCXX_USE_CXX11_ABI) && _GLIBCXX_USE_CXX11_ABI != 0)
+                // std::string requires default constructor for the small string optimization when using gcc's old ABI
+                // so don't assert then to allow joint allocator
+                static_assert(!alloc_reference::is_stateful::value,
+                              "default constructor must not be used for stateful allocators");
+#endif
+            }
+
+            /// \effects Creates it from a reference to a \c RawAllocator.
+            /// It will store an \ref allocator_reference to it.
+            /// \requires The expression <tt>allocator_reference<RawAllocator>(alloc)</tt> is well-formed,
+            /// that is either \c RawAlloc is the same as \c RawAllocator or \c RawAllocator is the tag type \ref any_allocator.
+            /// If the requirement is not fulfilled this function does not participate in overload resolution.
+            /// \note The caller has to ensure that the lifetime of the \c RawAllocator is at least as long as the lifetime
+            /// of this \ref std_allocator object.
+            template <
+                class RawAlloc,
+                // MSVC seems to ignore access rights in decltype SFINAE below
+                // use this to prevent this constructor being chosen instead of move/copy for types inheriting from it
+                WPI_REQUIRES((!std::is_base_of<std_allocator, RawAlloc>::value))>
+            std_allocator(RawAlloc& alloc, WPI_SFINAE(alloc_reference(alloc))) noexcept
+            : alloc_reference(alloc)
+            {
+            }
+
+            /// \effects Creates it from a stateless, temporary \c RawAllocator object.
+            /// It will not store a reference but create it on the fly.
+            /// \requires The \c RawAllocator is stateless
+            /// and the expression <tt>allocator_reference<RawAllocator>(alloc)</tt> is well-formed as above,
+            /// otherwise this function does not participate in overload resolution.
+            template <
+                class RawAlloc,
+                // MSVC seems to ignore access rights in decltype SFINAE below
+                // use this to prevent this constructor being chosen instead of move/copy for types inheriting from it
+                WPI_REQUIRES((!std::is_base_of<std_allocator, RawAlloc>::value))>
+            std_allocator(const RawAlloc& alloc, WPI_SFINAE(alloc_reference(alloc))) noexcept
+            : alloc_reference(alloc)
+            {
+            }
+
+            /// \effects Creates it from another \ref allocator_reference using the same allocator type.
+            std_allocator(const alloc_reference& alloc) noexcept : alloc_reference(alloc) {}
+
+            /// \details Implicit conversion from any other \ref allocator_storage is forbidden
+            /// to prevent accidentally wrapping another \ref allocator_storage inside a \ref allocator_reference.
+            template <class StoragePolicy, class OtherMut>
+            std_allocator(const allocator_storage<StoragePolicy, OtherMut>&) = delete;
+
+            /// @{
+            /// \effects Creates it from another \ref std_allocator allocating a different type.
+            /// This is required by the \c Allcoator concept and simply takes the same \ref allocator_reference.
+            template <typename U>
+            std_allocator(const std_allocator<U, RawAllocator>& alloc) noexcept
+            : alloc_reference(alloc)
+            {
+            }
+
+            template <typename U>
+            std_allocator(std_allocator<U, RawAllocator>& alloc) noexcept : alloc_reference(alloc)
+            {
+            }
+            /// @}
+
+            /// \returns A copy of the allocator.
+            /// This is required by the \c Allocator concept and forwards to the \ref propagation_traits.
+            std_allocator<T, RawAllocator> select_on_container_copy_construction() const
+            {
+                return prop_traits::select_on_container_copy_construction(*this);
+            }
+
+            //=== allocation/deallocation ===//
+            /// \effects Allocates memory using the underlying \concept{concept_rawallocator,RawAllocator}.
+            /// If \c n is \c 1, it will call <tt>allocate_node(sizeof(T), alignof(T))</tt>,
+            /// otherwise <tt>allocate_array(n, sizeof(T), alignof(T))</tt>.
+            /// \returns A pointer to a memory block suitable for \c n objects of type \c T.
+            /// \throws Anything thrown by the \c RawAllocator.
+            pointer allocate(size_type n, void* = nullptr)
+            {
+                return static_cast<pointer>(allocate_impl(is_any{}, n));
+            }
+
+            /// \effects Deallcoates memory using the underlying \concept{concept_rawallocator,RawAllocator}.
+            /// It will forward to the deallocation function in the same way as in \ref allocate().
+            /// \requires The pointer must come from a previous call to \ref allocate() with the same \c n on this object or any copy of it.
+            void deallocate(pointer p, size_type n) noexcept
+            {
+                deallocate_impl(is_any{}, p, n);
+            }
+
+            //=== construction/destruction ===//
+            /// \effects Creates an object of type \c U at given address using the passed arguments.
+            template <typename U, typename... Args>
+            void construct(U* p, Args&&... args)
+            {
+                void* mem = p;
+                ::new (mem) U(detail::forward<Args>(args)...);
+            }
+
+            /// \effects Calls the destructor for an object of type \c U at given address.
+            template <typename U>
+            void destroy(U* p) noexcept
+            {
+                // This is to avoid a MSVS 2015 'unreferenced formal parameter' warning
+                (void)p;
+                p->~U();
+            }
+
+            //=== getter ===//
+            /// \returns The maximum size for an allocation which is <tt>max_array_size() / sizeof(value_type)</tt>.
+            /// This is only an upper bound, not the exact maximum.
+            size_type max_size() const noexcept
+            {
+                return this->max_array_size() / sizeof(value_type);
+            }
+
+            /// @{
+            /// \effects Returns a reference to the referenced allocator.
+            /// \returns For stateful allocators: A (\c const) reference to the stored allocator.
+            /// For stateless allocators: A temporary constructed allocator.
+            auto get_allocator() noexcept
+                -> decltype(std::declval<alloc_reference>().get_allocator())
+            {
+                return alloc_reference::get_allocator();
+            }
+
+            auto get_allocator() const noexcept
+                -> decltype(std::declval<const alloc_reference>().get_allocator())
+            {
+                return alloc_reference::get_allocator();
+            }
+            /// @}
+
+        private:
+            // any_allocator_reference: use virtual function which already does a dispatch on node/array
+            void* allocate_impl(std::true_type, size_type n)
+            {
+                return get_allocator().allocate_impl(n, sizeof(T), alignof(T));
+            }
+
+            void deallocate_impl(std::true_type, void* ptr, size_type n)
+            {
+                get_allocator().deallocate_impl(ptr, n, sizeof(T), alignof(T));
+            }
+
+            // alloc_reference: decide between node/array
+            void* allocate_impl(std::false_type, size_type n)
+            {
+                if (n == 1)
+                    return this->allocate_node(sizeof(T), alignof(T));
+                else
+                    return this->allocate_array(n, sizeof(T), alignof(T));
+            }
+
+            void deallocate_impl(std::false_type, void* ptr, size_type n)
+            {
+                if (n == 1)
+                    this->deallocate_node(ptr, sizeof(T), alignof(T));
+                else
+                    this->deallocate_array(ptr, n, sizeof(T), alignof(T));
+            }
+
+            template <typename U> // stateful
+            bool equal_to_impl(std::true_type,
+                               const std_allocator<U, RawAllocator>& other) const noexcept
+            {
+                return &get_allocator() == &other.get_allocator();
+            }
+
+            template <typename U> // non-stateful
+            bool equal_to_impl(std::false_type,
+                               const std_allocator<U, RawAllocator>&) const noexcept
+            {
+                return true;
+            }
+
+            template <typename U> // shared
+            bool equal_to(std::true_type,
+                          const std_allocator<U, RawAllocator>& other) const noexcept
+            {
+                return get_allocator() == other.get_allocator();
+            }
+
+            template <typename U> // not shared
+            bool equal_to(std::false_type,
+                          const std_allocator<U, RawAllocator>& other) const noexcept
+            {
+                return equal_to_impl(typename allocator_traits<RawAllocator>::is_stateful{}, other);
+            }
+
+            template <typename T1, typename T2, class Impl>
+            friend bool operator==(const std_allocator<T1, Impl>& lhs,
+                                   const std_allocator<T2, Impl>& rhs) noexcept;
+
+            template <typename U, class OtherRawAllocator>
+            friend class std_allocator;
+        };
+
+        /// \effects Compares two \ref std_allocator object, they are equal if either stateless or reference the same allocator.
+        /// \returns The result of the comparision for equality.
+        /// \relates std_allocator
+        template <typename T, typename U, class Impl>
+        bool operator==(const std_allocator<T, Impl>& lhs,
+                        const std_allocator<U, Impl>& rhs) noexcept
+        {
+            return lhs.equal_to(is_shared_allocator<Impl>{}, rhs);
+        }
+
+        /// \effects Compares two \ref std_allocator object, they are equal if either stateless or reference the same allocator.
+        /// \returns The result of the comparision for inequality.
+        /// \relates std_allocator
+        template <typename T, typename U, class Impl>
+        bool operator!=(const std_allocator<T, Impl>& lhs,
+                        const std_allocator<U, Impl>& rhs) noexcept
+        {
+            return !(lhs == rhs);
+        }
+
+        /// \returns A new \ref std_allocator for a given type using a certain allocator object.
+        /// \relates std_allocator
+        template <typename T, class RawAllocator>
+        auto make_std_allocator(RawAllocator&& allocator) noexcept
+            -> std_allocator<T, typename std::decay<RawAllocator>::type>
+        {
+            return {detail::forward<RawAllocator>(allocator)};
+        }
+
+        /// An alias template for \ref std_allocator using a type-erased \concept{concept_rawallocator,RawAllocator}.
+        /// This is the same as using a \ref std_allocator with the tag type \ref any_allocator.
+        /// The implementation is optimized to call fewer virtual functions.
+        /// \ingroup adapter
+        template <typename T>
+        WPI_ALIAS_TEMPLATE(any_std_allocator, std_allocator<T, any_allocator>);
+
+        /// \returns A new \ref any_std_allocator for a given type using a certain allocator object.
+        /// \relates any_std_allocator
+        template <typename T, class RawAllocator>
+        any_std_allocator<T> make_any_std_allocator(RawAllocator&& allocator) noexcept
+        {
+            return {detail::forward<RawAllocator>(allocator)};
+        }
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_STD_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/temporary_allocator.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/temporary_allocator.hpp
new file mode 100644
index 0000000..7eba76f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/temporary_allocator.hpp
@@ -0,0 +1,335 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_TEMPORARY_ALLOCATOR_HPP_INCLUDED
+#define WPI_MEMORY_TEMPORARY_ALLOCATOR_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::temporary_allocator and related functions.
+
+#include "config.hpp"
+#include "memory_stack.hpp"
+
+#if WPI_MEMORY_TEMPORARY_STACK_MODE >= 2
+#include <atomic>
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        class temporary_allocator;
+        class temporary_stack;
+
+        namespace detail
+        {
+            class temporary_block_allocator
+            {
+            public:
+                explicit temporary_block_allocator(std::size_t block_size) noexcept;
+
+                memory_block allocate_block();
+
+                void deallocate_block(memory_block block);
+
+                std::size_t next_block_size() const noexcept
+                {
+                    return block_size_;
+                }
+
+                using growth_tracker = void (*)(std::size_t size);
+
+                growth_tracker set_growth_tracker(growth_tracker t) noexcept;
+
+                growth_tracker get_growth_tracker() noexcept;
+
+            private:
+                growth_tracker tracker_;
+                std::size_t    block_size_;
+            };
+
+            using temporary_stack_impl = memory_stack<temporary_block_allocator>;
+
+            class temporary_stack_list;
+
+#if WPI_MEMORY_TEMPORARY_STACK_MODE >= 2
+            class temporary_stack_list_node
+            {
+            public:
+                // doesn't add into list
+                temporary_stack_list_node() noexcept : in_use_(true) {}
+
+                temporary_stack_list_node(int) noexcept;
+
+                ~temporary_stack_list_node() noexcept {}
+
+            private:
+                temporary_stack_list_node* next_ = nullptr;
+                std::atomic<bool>          in_use_;
+
+                friend temporary_stack_list;
+            };
+
+            static class temporary_allocator_dtor_t
+            {
+            public:
+                temporary_allocator_dtor_t() noexcept;
+                ~temporary_allocator_dtor_t() noexcept;
+            } temporary_allocator_dtor;
+#else
+            class temporary_stack_list_node
+            {
+            protected:
+                temporary_stack_list_node() noexcept {}
+
+                temporary_stack_list_node(int) noexcept {}
+
+                ~temporary_stack_list_node() noexcept {}
+            };
+#endif
+        } // namespace detail
+
+        /// A wrapper around the \ref memory_stack that is used by the \ref temporary_allocator.
+        /// There should be at least one per-thread.
+        /// \ingroup allocator
+        class temporary_stack : WPI_EBO(detail::temporary_stack_list_node)
+        {
+        public:
+            /// The type of the handler called when the internal \ref memory_stack grows.
+            /// It gets the size of the new block that will be allocated.
+            /// \requiredbe The handler shall log the growth, throw an exception or aborts the program.
+            /// If this function does not return, the growth is prevented but the allocator unusable until memory is freed.
+            /// \defaultbe The default handler does nothing.
+            using growth_tracker = detail::temporary_block_allocator::growth_tracker;
+
+            /// \effects Sets \c h as the new \ref growth_tracker.
+            /// A \c nullptr sets the default \ref growth_tracker.
+            /// Each thread has its own, separate tracker.
+            /// \returns The previous \ref growth_tracker. This is never \c nullptr.
+            growth_tracker set_growth_tracker(growth_tracker t) noexcept
+            {
+                return stack_.get_allocator().set_growth_tracker(t);
+            }
+
+            /// \returns The current \ref growth_tracker. This is never \c nullptr.
+            growth_tracker get_growth_tracker() noexcept
+            {
+                return stack_.get_allocator().get_growth_tracker();
+            }
+
+            /// \effects Creates it with a given initial size of the stack.
+            /// It can grow if needed, although that is expensive.
+            /// \requires `initial_size` must be greater than `0`.
+            explicit temporary_stack(std::size_t initial_size) : stack_(initial_size), top_(nullptr)
+            {
+            }
+
+            /// \returns `next_capacity()` of the internal `memory_stack`.
+            std::size_t next_capacity() const noexcept
+            {
+                return stack_.next_capacity();
+            }
+
+        private:
+            temporary_stack(int i, std::size_t initial_size)
+            : detail::temporary_stack_list_node(i), stack_(initial_size), top_(nullptr)
+            {
+            }
+
+            using marker = detail::temporary_stack_impl::marker;
+
+            marker top() const noexcept
+            {
+                return stack_.top();
+            }
+
+            void unwind(marker m) noexcept
+            {
+                stack_.unwind(m);
+            }
+
+            detail::temporary_stack_impl stack_;
+            temporary_allocator*         top_;
+
+#if !defined(DOXYGEN)
+            friend temporary_allocator;
+            friend memory_stack_raii_unwind<temporary_stack>;
+            friend detail::temporary_stack_list;
+#endif
+        };
+
+        /// Manually takes care of the lifetime of the per-thread \ref temporary_stack.
+        /// The constructor will create it, if not already done, and the destructor will destroy it, if not already done.
+        /// \note If there are multiple objects in a thread,
+        /// this will lead to unnecessary construction and destruction of the stack.
+        /// It is thus adviced to create one object on the top-level function of the thread, e.g. in `main()`.
+        /// \note If `WPI_MEMORY_TEMPORARY_STACK_MODE == 2`, it is not necessary to use this class,
+        /// the nifty counter will clean everything upon program termination.
+        /// But it can still be used as an optimization if you have a thread that is terminated long before program exit.
+        /// The automatic clean up will only occur much later.
+        /// \note If `WPI_MEMORY_TEMPORARY_STACK_MODE == 0`, the use of this class has no effect,
+        /// because the per-thread stack is disabled.
+        /// \relatesalso temporary_stack
+        class temporary_stack_initializer
+        {
+        public:
+            static constexpr std::size_t default_stack_size = 4096u;
+
+            static const struct defer_create_t
+            {
+                defer_create_t() noexcept {}
+            } defer_create;
+
+            /// \effects Does not create the per-thread stack.
+            /// It will be created by the first call to \ref get_temporary_stack() in the current thread.
+            /// \note If `WPI_MEMORY_TEMPORARY_STACK_MODE == 0`, this function has no effect.
+            temporary_stack_initializer(defer_create_t) noexcept {}
+
+            /// \effects Creates the per-thread stack with the given default size if it wasn't already created.
+            /// \requires `initial_size` must not be `0` if `WPI_MEMORY_TEMPORARY_STACK_MODE != 0`.
+            /// \note If `WPI_MEMORY_TEMPORARY_STACK_MODE == 0`, this function will issue a warning in debug mode.
+            /// This can be disabled by passing `0` as the initial size.
+            temporary_stack_initializer(std::size_t initial_size = default_stack_size);
+
+            /// \effects Destroys the per-thread stack if it isn't already destroyed.
+            ~temporary_stack_initializer() noexcept;
+
+            temporary_stack_initializer(temporary_stack_initializer&&) = delete;
+            temporary_stack_initializer& operator=(temporary_stack_initializer&&) = delete;
+        };
+
+        /// \effects Creates the per-thread \ref temporary_stack with the given initial size,
+        /// if it wasn't already created.
+        /// \returns The per-thread \ref temporary_stack.
+        /// \requires There must be a per-thread temporary stack (\ref WPI_MEMORY_TEMPORARY_STACK_MODE must not be equal to `0`).
+        /// \note If \ref WPI_MEMORY_TEMPORARY_STACK_MODE is equal to `1`,
+        /// this function can create the temporary stack.
+        /// But if there is no \ref temporary_stack_initializer, it won't be destroyed.
+        /// \relatesalso temporary_stack
+        temporary_stack& get_temporary_stack(
+            std::size_t initial_size = temporary_stack_initializer::default_stack_size);
+
+        /// A stateful \concept{concept_rawallocator,RawAllocator} that handles temporary allocations.
+        /// It works similar to \c alloca() but uses a seperate \ref memory_stack for the allocations,
+        /// instead of the actual program stack.
+        /// This avoids the stack overflow error and is portable,
+        /// with a similar speed.
+        /// All allocations done in the scope of the allocator object are automatically freed when the object is destroyed.
+        /// \ingroup allocator
+        class temporary_allocator
+        {
+        public:
+            /// \effects Creates it by using the \ref get_temporary_stack() to get the temporary stack.
+            /// \requires There must be a per-thread temporary stack (\ref WPI_MEMORY_TEMPORARY_STACK_MODE must not be equal to `0`).
+            temporary_allocator();
+
+            /// \effects Creates it by giving it the \ref temporary_stack it uses for allocation.
+            explicit temporary_allocator(temporary_stack& stack);
+
+            ~temporary_allocator() noexcept;
+
+            temporary_allocator(temporary_allocator&&) = delete;
+            temporary_allocator& operator=(temporary_allocator&&) = delete;
+
+            /// \effects Allocates memory from the internal \ref memory_stack by forwarding to it.
+            /// \returns The result of \ref memory_stack::allocate().
+            /// \requires `is_active()` must return `true`.
+            void* allocate(std::size_t size, std::size_t alignment);
+
+            /// \returns Whether or not the allocator object is active.
+            /// \note The active allocator object is the last object created for one stack.
+            /// Moving changes the active allocator.
+            bool is_active() const noexcept;
+
+            /// \effects Instructs it to release unnecessary memory after automatic unwinding occurs.
+            /// This will effectively forward to \ref memory_stack::shrink_to_fit() of the internal stack.
+            /// \note Like the use of the \ref temporary_stack_initializer this can be used as an optimization,
+            /// to tell when the thread's \ref temporary_stack isn't needed anymore and can be destroyed.
+            /// \note It doesn't call shrink to fit immediately, only in the destructor!
+            void shrink_to_fit() noexcept;
+
+            /// \returns The internal stack the temporary allocator is using.
+            /// \requires `is_active()` must return `true`.
+            temporary_stack& get_stack() const noexcept
+            {
+                return unwind_.get_stack();
+            }
+
+        private:
+            memory_stack_raii_unwind<temporary_stack> unwind_;
+            temporary_allocator*                      prev_;
+            bool                                      shrink_to_fit_;
+        };
+
+        template <class Allocator>
+        class allocator_traits;
+
+        /// Specialization of the \ref allocator_traits for \ref temporary_allocator classes.
+        /// \note It is not allowed to mix calls through the specialization and through the member functions,
+        /// i.e. \ref temporary_allocator::allocate() and this \c allocate_node().
+        /// \ingroup allocator
+        template <>
+        class allocator_traits<temporary_allocator>
+        {
+        public:
+            using allocator_type = temporary_allocator;
+            using is_stateful    = std::true_type;
+
+            /// \returns The result of \ref temporary_allocator::allocate().
+            static void* allocate_node(allocator_type& state, std::size_t size,
+                                       std::size_t alignment)
+            {
+                detail::check_allocation_size<bad_node_size>(size,
+                                                             [&] { return max_node_size(state); },
+                                                             {WPI_MEMORY_LOG_PREFIX
+                                                              "::temporary_allocator",
+                                                              &state});
+                return state.allocate(size, alignment);
+            }
+
+            /// \returns The result of \ref temporary_allocator::allocate().
+            static void* allocate_array(allocator_type& state, std::size_t count, std::size_t size,
+                                        std::size_t alignment)
+            {
+                return allocate_node(state, count * size, alignment);
+            }
+
+            /// @{
+            /// \effects Does nothing besides bookmarking for leak checking, if that is enabled.
+            /// Actual deallocation will be done automatically if the allocator object goes out of scope.
+            static void deallocate_node(const allocator_type&, void*, std::size_t,
+                                        std::size_t) noexcept
+            {
+            }
+
+            static void deallocate_array(const allocator_type&, void*, std::size_t, std::size_t,
+                                         std::size_t) noexcept
+            {
+            }
+            /// @}
+
+            /// @{
+            /// \returns The maximum size which is \ref memory_stack::next_capacity() of the internal stack.
+            static std::size_t max_node_size(const allocator_type& state) noexcept
+            {
+                return state.get_stack().next_capacity();
+            }
+
+            static std::size_t max_array_size(const allocator_type& state) noexcept
+            {
+                return max_node_size(state);
+            }
+            /// @}
+
+            /// \returns The maximum possible value since there is no alignment restriction
+            /// (except indirectly through \ref memory_stack::next_capacity()).
+            static std::size_t max_alignment(const allocator_type&) noexcept
+            {
+                return std::size_t(-1);
+            }
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_TEMPORARY_ALLOCATOR_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/threading.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/threading.hpp
new file mode 100644
index 0000000..0314ea4
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/threading.hpp
@@ -0,0 +1,155 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_THREADING_HPP_INCLUDED
+#define WPI_MEMORY_THREADING_HPP_INCLUDED
+
+/// \file
+/// The mutex types.
+
+#include <type_traits>
+
+#include "allocator_traits.hpp"
+#include "config.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <mutex>
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        /// A dummy \c Mutex class that does not lock anything.
+        /// It is a valid \c Mutex and can be used to disable locking anywhere a \c Mutex is requested.
+        /// \ingroup core
+        struct no_mutex
+        {
+            void lock() noexcept {}
+
+            bool try_lock() noexcept
+            {
+                return true;
+            }
+
+            void unlock() noexcept {}
+        };
+
+        /// Specifies whether or not a \concept{concept_rawallocator,RawAllocator} is thread safe as-is.
+        /// This allows to use \ref no_mutex as an optimization.
+        /// Note that stateless allocators are implictly thread-safe.
+        /// Specialize it only for your own stateful allocators.
+        /// \ingroup core
+        template <class RawAllocator>
+        struct is_thread_safe_allocator
+        : std::integral_constant<bool, !allocator_traits<RawAllocator>::is_stateful::value>
+        {
+        };
+
+        namespace detail
+        {
+            // selects a mutex for an Allocator
+            // stateless allocators don't need locking
+            template <class RawAllocator, class Mutex>
+            using mutex_for =
+                typename std::conditional<is_thread_safe_allocator<RawAllocator>::value, no_mutex,
+                                          Mutex>::type;
+
+            // storage for mutexes to use EBO
+            // it provides const lock/unlock function, inherit from it
+            template <class Mutex>
+            class mutex_storage
+            {
+            public:
+                mutex_storage() noexcept = default;
+                mutex_storage(const mutex_storage&) noexcept {}
+
+                mutex_storage& operator=(const mutex_storage&) noexcept
+                {
+                    return *this;
+                }
+
+                void lock() const
+                {
+                    mutex_.lock();
+                }
+
+                void unlock() const noexcept
+                {
+                    mutex_.unlock();
+                }
+
+            protected:
+                ~mutex_storage() noexcept = default;
+
+            private:
+                mutable Mutex mutex_;
+            };
+
+            template <>
+            class mutex_storage<no_mutex>
+            {
+            public:
+                mutex_storage() noexcept = default;
+
+                void lock() const noexcept {}
+                void unlock() const noexcept {}
+
+            protected:
+                ~mutex_storage() noexcept = default;
+            };
+
+            // non changeable pointer to an Allocator that keeps a lock
+            // I don't think EBO is necessary here...
+            template <class Alloc, class Mutex>
+            class locked_allocator
+            {
+            public:
+                locked_allocator(Alloc& alloc, Mutex& m) noexcept : mutex_(&m), alloc_(&alloc)
+                {
+                    mutex_->lock();
+                }
+
+                locked_allocator(locked_allocator&& other) noexcept
+                : mutex_(other.mutex_), alloc_(other.alloc_)
+                {
+                    other.mutex_ = nullptr;
+                    other.alloc_ = nullptr;
+                }
+
+                ~locked_allocator() noexcept
+                {
+                    if (mutex_)
+                        mutex_->unlock();
+                }
+
+                locked_allocator& operator=(locked_allocator&& other) noexcept = delete;
+
+                Alloc& operator*() const noexcept
+                {
+                    WPI_MEMORY_ASSERT(alloc_);
+                    return *alloc_;
+                }
+
+                Alloc* operator->() const noexcept
+                {
+                    WPI_MEMORY_ASSERT(alloc_);
+                    return alloc_;
+                }
+
+            private:
+                Mutex* mutex_; // don't use unqiue_lock to avoid dependency
+                Alloc* alloc_;
+            };
+
+            template <class Alloc, class Mutex>
+            locked_allocator<Alloc, Mutex> lock_allocator(Alloc& a, Mutex& m)
+            {
+                return {a, m};
+            }
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_THREADING_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/tracking.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/tracking.hpp
new file mode 100644
index 0000000..ccbc343
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/tracking.hpp
@@ -0,0 +1,430 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_TRACKING_HPP_INCLUDED
+#define WPI_MEMORY_TRACKING_HPP_INCLUDED
+
+/// \file
+/// Class \ref wpi::memory::tracked_allocator and related classes and functions.
+
+#include "detail/utility.hpp"
+#include "allocator_traits.hpp"
+#include "memory_arena.hpp"
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            template <class Allocator, class Tracker>
+            auto set_tracker(int, Allocator& allocator, Tracker* tracker) noexcept
+                -> decltype(allocator.get_allocator().set_tracker(tracker))
+            {
+                return allocator.get_allocator().set_tracker(tracker);
+            }
+            template <class Allocator, class Tracker>
+            void set_tracker(short, Allocator&, Tracker*) noexcept
+            {
+            }
+
+            // used with deeply_tracked_allocator
+            template <class Tracker, class BlockAllocator>
+            class deeply_tracked_block_allocator : WPI_EBO(BlockAllocator)
+            {
+            public:
+                template <typename... Args>
+                deeply_tracked_block_allocator(std::size_t block_size, Args&&... args)
+                : BlockAllocator(block_size, detail::forward<Args>(args)...), tracker_(nullptr)
+                {
+                }
+
+                memory_block allocate_block()
+                {
+                    auto block = BlockAllocator::allocate_block();
+                    if (tracker_) // on first call tracker_ is nullptr
+                        tracker_->on_allocator_growth(block.memory, block.size);
+                    return block;
+                }
+
+                void deallocate_block(memory_block block) noexcept
+                {
+                    if (tracker_) // on last call tracker_ is nullptr again
+                        tracker_->on_allocator_shrinking(block.memory, block.size);
+                    BlockAllocator::deallocate_block(block);
+                }
+
+                std::size_t next_block_size() const noexcept
+                {
+                    return BlockAllocator::next_block_size();
+                }
+
+                void set_tracker(Tracker* tracker) noexcept
+                {
+                    tracker_ = tracker;
+                }
+
+            private:
+                Tracker* tracker_;
+            };
+        } // namespace detail
+
+        /// A \concept{concept_blockallocator,BlockAllocator} adapter that tracks another allocator using a \concept{concept_tracker,tracker}.
+        /// It wraps another \concept{concept_blockallocator,BlockAllocator} and calls the tracker function before forwarding to it.
+        /// The class can then be used anywhere a \concept{concept_blockallocator,BlockAllocator} is required and the memory usage will be tracked.<br>
+        /// It will only call the <tt>on_allocator_growth()</tt> and <tt>on_allocator_shrinking()</tt> tracking functions,
+        /// since a \concept{concept_blockallocator,BlockAllocator} is normally used inside higher allocators only.
+        /// \ingroup adapter
+        template <class Tracker, class BlockOrRawAllocator>
+        class tracked_block_allocator
+        : WPI_EBO(Tracker, make_block_allocator_t<BlockOrRawAllocator>)
+        {
+        public:
+            using allocator_type = make_block_allocator_t<BlockOrRawAllocator>;
+            using tracker        = Tracker;
+
+            /// @{
+            /// \effects Creates it by giving it a \concept{concept_tracker,tracker} and the tracked \concept{concept_rawallocator,RawAllocator}.
+            /// It will embed both objects.
+            explicit tracked_block_allocator(tracker t = {}) noexcept : tracker(detail::move(t)) {}
+
+            tracked_block_allocator(tracker t, allocator_type&& alloc) noexcept
+            : tracker(detail::move(t)), allocator_type(detail::move(alloc))
+            {
+            }
+            /// @}
+
+            /// \effects Creates it in the form required by the concept.
+            /// The allocator will be constructed using \c block_size and \c args.
+            template <typename... Args>
+            tracked_block_allocator(std::size_t block_size, tracker t, Args&&... args)
+            : tracker(detail::move(t)), allocator_type(block_size, detail::forward<Args>(args)...)
+            {
+            }
+
+            /// \effects Calls <tt>Tracker::on_allocator_growth()</tt> after forwarding to the allocator.
+            /// \returns The block as the returned by the allocator.
+            memory_block allocate_block()
+            {
+                auto block = allocator_type::allocate_block();
+                this->on_allocator_growth(block.memory, block.size);
+                return block;
+            }
+
+            /// \effects Calls <tt>Tracker::on_allocator_shrinking()</tt> and forwards to the allocator.
+            void deallocate_block(memory_block block) noexcept
+            {
+                this->on_allocator_shrinking(block.memory, block.size);
+                allocator_type::deallocate_block(block);
+            }
+
+            /// \returns The next block size as returned by the allocator.
+            std::size_t next_block_size() const noexcept
+            {
+                return allocator_type::next_block_size();
+            }
+
+            /// @{
+            /// \returns A (const) reference to the used allocator.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (const) reference to the tracker.
+            tracker& get_tracker() noexcept
+            {
+                return *this;
+            }
+
+            const tracker& get_tracker() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+        };
+
+        /// Similar to \ref tracked_block_allocator, but shares the tracker with the higher level allocator.
+        /// This allows tracking both (de-)allocations and growth with one tracker.
+        /// \note Due to implementation reasons, it cannot track growth and shrinking in the constructor/destructor of the higher level allocator.
+        /// \ingroup adapter
+        template <class Tracker, class BlockOrRawAllocator>
+        using deeply_tracked_block_allocator = WPI_IMPL_DEFINED(
+            detail::deeply_tracked_block_allocator<Tracker,
+                                                   make_block_allocator_t<BlockOrRawAllocator>>);
+
+        /// A \concept{concept_rawallocator,RawAllocator} adapter that tracks another allocator using a \concept{concept_tracker,tracker}.
+        /// It wraps another \concept{concept_rawallocator,RawAllocator} and calls the tracker function before forwarding to it.
+        /// The class can then be used anywhere a \concept{concept_rawallocator,RawAllocator} is required and the memory usage will be tracked.<br>
+        /// If the \concept{concept_rawallocator,RawAllocator} uses \ref deeply_tracked_block_allocator as \concept{concept_blockallocator,BlockAllocator},
+        /// it will also track growth and shrinking of the allocator.
+        /// \ingroup adapter
+        template <class Tracker, class RawAllocator>
+        class tracked_allocator
+        : WPI_EBO(Tracker, allocator_traits<RawAllocator>::allocator_type)
+        {
+            using traits            = allocator_traits<RawAllocator>;
+            using composable_traits = composable_allocator_traits<RawAllocator>;
+
+        public:
+            using allocator_type = typename allocator_traits<RawAllocator>::allocator_type;
+            using tracker        = Tracker;
+
+            using is_stateful = std::integral_constant<bool, traits::is_stateful::value
+                                                                 || !std::is_empty<Tracker>::value>;
+
+            /// @{
+            /// \effects Creates it by giving it a \concept{concept_tracker,tracker} and the tracked \concept{concept_rawallocator,RawAllocator}.
+            /// It will embed both objects.
+            /// \note This will never call the <tt>Tracker::on_allocator_growth()</tt> function.
+            explicit tracked_allocator(tracker t = {}) noexcept
+            : tracked_allocator(detail::move(t), allocator_type{})
+            {
+            }
+
+            tracked_allocator(tracker t, allocator_type&& allocator) noexcept
+            : tracker(detail::move(t)), allocator_type(detail::move(allocator))
+            {
+                detail::set_tracker(0, get_allocator(), &get_tracker());
+            }
+            /// @}
+
+            /// \effects Destroys both tracker and allocator.
+            /// \note This will never call the <tt>Tracker::on_allocator_shrinking()</tt> function.
+            ~tracked_allocator() noexcept
+            {
+                detail::set_tracker(0, get_allocator(), static_cast<tracker*>(nullptr));
+            }
+
+            /// @{
+            /// \effects Moving moves both the tracker and the allocator.
+            tracked_allocator(tracked_allocator&& other) noexcept
+            : tracker(detail::move(other)), allocator_type(detail::move(other))
+            {
+                detail::set_tracker(0, get_allocator(), &get_tracker());
+            }
+
+            tracked_allocator& operator=(tracked_allocator&& other) noexcept
+            {
+                tracker::       operator=(detail::move(other));
+                allocator_type::operator=(detail::move(other));
+                detail::set_tracker(0, get_allocator(), &get_tracker());
+                return *this;
+            }
+            /// @}
+
+            /// \effects Calls <tt>Tracker::on_node_allocation()</tt> and forwards to the allocator.
+            /// If a growth occurs and the allocator is deeply tracked, also calls <tt>Tracker::on_allocator_growth()</tt>.
+            /// \returns The result of <tt>allocate_node()</tt>
+            void* allocate_node(std::size_t size, std::size_t alignment)
+            {
+                auto mem = traits::allocate_node(get_allocator(), size, alignment);
+                this->on_node_allocation(mem, size, alignment);
+                return mem;
+            }
+
+            /// \effects Calls the composable node allocation function.
+            /// If allocation was successful, also calls `Tracker::on_node_allocation()`.
+            /// \returns The result of `try_allocate_node()`.
+            void* try_allocate_node(std::size_t size, std::size_t alignment) noexcept
+            {
+                auto mem = composable_traits::try_allocate_node(get_allocator(), size, alignment);
+                if (mem)
+                    this->on_node_allocation(mem, size, alignment);
+                return mem;
+            }
+
+            /// \effects Calls <tt>Tracker::on_array_allocation()</tt> and forwards to the allocator.
+            /// If a growth occurs and the allocator is deeply tracked, also calls <tt>Tracker::on_allocator_growth()</tt>.
+            /// \returns The result of <tt>allocate_array()</tt>
+            void* allocate_array(std::size_t count, std::size_t size, std::size_t alignment)
+            {
+                auto mem = traits::allocate_array(get_allocator(), count, size, alignment);
+                this->on_array_allocation(mem, count, size, alignment);
+                return mem;
+            }
+
+            /// \effects Calls the composable array allocation function.
+            /// If allocation was succesful, also calls `Tracker::on_array_allocation()`.
+            /// \returns The result of `try_allocate_array()`.
+            void* try_allocate_array(std::size_t count, std::size_t size,
+                                     std::size_t alignment) noexcept
+            {
+                auto mem =
+                    composable_traits::try_allocate_array(get_allocator(), count, size, alignment);
+                if (mem)
+                    this->on_array_allocation(mem, count, size, alignment);
+                return mem;
+            }
+
+            /// \effects Calls <tt>Tracker::on_node_deallocation()</tt> and forwards to the allocator's <tt>deallocate_node()</tt>.
+            /// If shrinking occurs and the allocator is deeply tracked, also calls <tt>Tracker::on_allocator_shrinking()</tt>.
+            void deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                this->on_node_deallocation(ptr, size, alignment);
+                traits::deallocate_node(get_allocator(), ptr, size, alignment);
+            }
+
+            /// \effects Calls the composable node deallocation function.
+            /// If it was succesful, also calls `Tracker::on_node_deallocation()`.
+            /// \returns The result of `try_deallocate_node()`.
+            bool try_deallocate_node(void* ptr, std::size_t size, std::size_t alignment) noexcept
+            {
+                auto res =
+                    composable_traits::try_deallocate_node(get_allocator(), ptr, size, alignment);
+                if (res)
+                    this->on_node_deallocation(ptr, size, alignment);
+                return res;
+            }
+
+            /// \effects Calls <tt>Tracker::on_array_deallocation()</tt> and forwards to the allocator's <tt>deallocate_array()</tt>.
+            /// If shrinking occurs and the allocator is deeply tracked, also calls <tt>Tracker::on_allocator_shrinking()</tt>.
+            void deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                  std::size_t alignment) noexcept
+            {
+                this->on_array_deallocation(ptr, count, size, alignment);
+                traits::deallocate_array(get_allocator(), ptr, count, size, alignment);
+            }
+
+            /// \effects Calls the composable array deallocation function.
+            /// If it was succesful, also calls `Tracker::on_array_deallocation()`.
+            /// \returns The result of `try_deallocate_array()`.
+            bool try_deallocate_array(void* ptr, std::size_t count, std::size_t size,
+                                      std::size_t alignment) noexcept
+            {
+                auto res = composable_traits::try_deallocate_array(ptr, count, size, alignment);
+                if (res)
+                    this->on_array_deallocation(ptr, count, size, alignment);
+                return res;
+            }
+
+            /// @{
+            /// \returns The result of the corresponding function on the wrapped allocator.
+            std::size_t max_node_size() const
+            {
+                return traits::max_node_size(get_allocator());
+            }
+
+            std::size_t max_array_size() const
+            {
+                return traits::max_array_size(get_allocator());
+            }
+
+            std::size_t max_alignment() const
+            {
+                return traits::max_alignment(get_allocator());
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (\c const) reference to the wrapped allocator.
+            allocator_type& get_allocator() noexcept
+            {
+                return *this;
+            }
+
+            const allocator_type& get_allocator() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+
+            /// @{
+            /// \returns A (\c const) reference to the tracker.
+            tracker& get_tracker() noexcept
+            {
+                return *this;
+            }
+
+            const tracker& get_tracker() const noexcept
+            {
+                return *this;
+            }
+            /// @}
+        };
+
+        /// \effects Takes a \concept{concept_rawallocator,RawAllocator} and wraps it with a \concept{concept_tracker,tracker}.
+        /// \returns A \ref tracked_allocator with the corresponding parameters forwarded to the constructor.
+        /// \relates tracked_allocator
+        template <class Tracker, class RawAllocator>
+        auto make_tracked_allocator(Tracker t, RawAllocator&& alloc)
+            -> tracked_allocator<Tracker, typename std::decay<RawAllocator>::type>
+        {
+            return tracked_allocator<Tracker, typename std::decay<RawAllocator>::type>{detail::move(
+                                                                                           t),
+                                                                                       detail::move(
+                                                                                           alloc)};
+        }
+
+        namespace detail
+        {
+            template <typename T, bool Block>
+            struct is_block_or_raw_allocator_impl : std::true_type
+            {
+            };
+
+            template <typename T>
+            struct is_block_or_raw_allocator_impl<T, false> : memory::is_raw_allocator<T>
+            {
+            };
+
+            template <typename T>
+            struct is_block_or_raw_allocator
+            : is_block_or_raw_allocator_impl<T, memory::is_block_allocator<T>::value>
+            {
+            };
+
+            template <class RawAllocator, class BlockAllocator>
+            struct rebind_block_allocator;
+
+            template <template <typename...> class RawAllocator, typename... Args,
+                      class OtherBlockAllocator>
+            struct rebind_block_allocator<RawAllocator<Args...>, OtherBlockAllocator>
+            {
+                using type =
+                    RawAllocator<typename std::conditional<is_block_or_raw_allocator<Args>::value,
+                                                           OtherBlockAllocator, Args>::type...>;
+            };
+
+            template <class Tracker, class RawAllocator>
+            using deeply_tracked_block_allocator_for =
+                memory::deeply_tracked_block_allocator<Tracker,
+                                                       typename RawAllocator::allocator_type>;
+
+            template <class Tracker, class RawAllocator>
+            using rebound_allocator = typename rebind_block_allocator<
+                RawAllocator, deeply_tracked_block_allocator_for<Tracker, RawAllocator>>::type;
+        } // namespace detail
+
+        /// A \ref tracked_allocator that has rebound any \concept{concept_blockallocator,BlockAllocator} to the corresponding \ref deeply_tracked_block_allocator.
+        /// This makes it a deeply tracked allocator.<br>
+        /// It replaces each template argument of the given \concept{concept_rawallocator,RawAllocator} for which \ref is_block_allocator or \ref is_raw_allocator is \c true with a \ref deeply_tracked_block_allocator.
+        /// \ingroup adapter
+        template <class Tracker, class RawAllocator>
+        WPI_ALIAS_TEMPLATE(
+            deeply_tracked_allocator,
+            tracked_allocator<Tracker, detail::rebound_allocator<Tracker, RawAllocator>>);
+
+        /// \effects Takes a \concept{concept_rawallocator,RawAllocator} and deeply wraps it with a \concept{concept_tracker,tracker}.
+        /// \returns A \ref deeply_tracked_allocator with the corresponding parameters forwarded to the constructor.
+        /// \relates deeply_tracked_allocator
+        template <class RawAllocator, class Tracker, typename... Args>
+        auto make_deeply_tracked_allocator(Tracker t, Args&&... args)
+            -> deeply_tracked_allocator<Tracker, RawAllocator>
+        {
+            return deeply_tracked_allocator<Tracker, RawAllocator>(detail::move(t),
+                                                                   {detail::forward<Args>(
+                                                                       args)...});
+        }
+    } // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_TRACKING_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/virtual_memory.hpp b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/virtual_memory.hpp
new file mode 100644
index 0000000..33d82f7
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/include/wpi/memory/virtual_memory.hpp
@@ -0,0 +1,202 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_VIRTUAL_MEMORY_HPP_INCLUDED
+#define WPI_MEMORY_VIRTUAL_MEMORY_HPP_INCLUDED
+
+/// \file
+/// Virtual memory api and (low-level) allocator classes.
+
+#include <cstddef>
+#include <type_traits>
+
+#include "detail/debug_helpers.hpp"
+#include "detail/utility.hpp"
+#include "config.hpp"
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+#include "allocator_traits.hpp"
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            struct virtual_memory_allocator_leak_handler
+            {
+                void operator()(std::ptrdiff_t amount);
+            };
+
+            WPI_MEMORY_GLOBAL_LEAK_CHECKER(virtual_memory_allocator_leak_handler,
+                                                 virtual_memory_allocator_leak_checker)
+        } // namespace detail
+
+        /// The page size of the virtual memory.
+        /// All virtual memory allocations must be multiple of this size.
+        /// It is usually 4KiB.
+        /// \ingroup allocator
+        /// \deprecated use \ref get_virtual_memory_page_size instead.
+        extern const std::size_t virtual_memory_page_size;
+
+        /// \returns the page size of the virtual memory.
+        /// All virtual memory allocations must be multiple of this size.
+        /// It is usually 4KiB.
+        /// \ingroup allocator
+        std::size_t get_virtual_memory_page_size() noexcept;
+
+        /// Reserves virtual memory.
+        /// \effects Reserves the given number of pages.
+        /// Each page is \ref virtual_memory_page_size big.
+        /// \returns The address of the first reserved page,
+        /// or \c nullptr in case of error.
+        /// \note The memory may not be used, it must first be commited.
+        /// \ingroup allocator
+        void* virtual_memory_reserve(std::size_t no_pages) noexcept;
+
+        /// Releases reserved virtual memory.
+        /// \effects Returns previously reserved pages to the system.
+        /// \requires \c pages must come from a previous call to \ref virtual_memory_reserve with the same \c calc_no_pages,
+        /// it must not be \c nullptr.
+        /// \ingroup allocator
+        void virtual_memory_release(void* pages, std::size_t no_pages) noexcept;
+
+        /// Commits reserved virtual memory.
+        /// \effects Marks \c calc_no_pages pages starting at the given address available for use.
+        /// \returns The beginning of the committed area, i.e. \c memory, or \c nullptr in case of error.
+        /// \requires The memory must be previously reserved.
+        /// \ingroup allocator
+        void* virtual_memory_commit(void* memory, std::size_t no_pages) noexcept;
+
+        /// Decommits commited virtual memory.
+        /// \effects Puts commited memory back in the reserved state.
+        /// \requires \c memory must come from a previous call to \ref virtual_memory_commit with the same \c calc_no_pages
+        /// it must not be \c nullptr.
+        /// \ingroup allocator
+        void virtual_memory_decommit(void* memory, std::size_t no_pages) noexcept;
+
+        /// A stateless \concept{concept_rawallocator,RawAllocator} that allocates memory using the virtual memory allocation functions.
+        /// It does not prereserve any memory and will always reserve and commit combined.
+        /// \ingroup allocator
+        class virtual_memory_allocator
+        : WPI_EBO(detail::global_leak_checker<detail::virtual_memory_allocator_leak_handler>)
+        {
+        public:
+            using is_stateful = std::false_type;
+
+            virtual_memory_allocator() noexcept = default;
+            virtual_memory_allocator(virtual_memory_allocator&&) noexcept {}
+            ~virtual_memory_allocator() noexcept = default;
+
+            virtual_memory_allocator& operator=(virtual_memory_allocator&&) noexcept
+            {
+                return *this;
+            }
+
+            /// \effects A \concept{concept_rawallocator,RawAllocator} allocation function.
+            /// It uses \ref virtual_memory_reserve followed by \ref virtual_memory_commit for the allocation.
+            /// The number of pages allocated will be the minimum to hold \c size continuous bytes,
+            /// i.e. \c size will be rounded up to the next multiple.
+            /// If debug fences are activated, one additional page before and after the memory will be allocated.
+            /// \returns A pointer to a \concept{concept_node,node}, it will never be \c nullptr.
+            /// It will always be aligned on a fence boundary, regardless of the alignment parameter.
+            /// \throws An exception of type \ref out_of_memory or whatever is thrown by its handler if the allocation fails.
+            void* allocate_node(std::size_t size, std::size_t alignment);
+
+            /// \effects A \concept{concept_rawallocator,RawAllocator} deallocation function.
+            /// It calls \ref virtual_memory_decommit followed by \ref virtual_memory_release for the deallocation.
+            void deallocate_node(void* node, std::size_t size, std::size_t alignment) noexcept;
+
+            /// \returns The maximum node size by returning the maximum value.
+            std::size_t max_node_size() const noexcept;
+
+            /// \returns The maximum alignment which is the same as the \ref virtual_memory_page_size.
+            std::size_t max_alignment() const noexcept;
+        };
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+        extern template class allocator_traits<virtual_memory_allocator>;
+#endif
+
+        struct memory_block;
+        struct allocator_info;
+
+        /// A \concept{concept_blockallocator,BlockAllocator} that reserves virtual memory and commits it part by part.
+        /// It is similar to \ref memory_stack but does not support growing and uses virtual memory,
+        /// also meant for big blocks not small allocations.
+        /// \ingroup allocator
+        class virtual_block_allocator
+        {
+        public:
+            /// \effects Creates it giving it the block size and the total number of blocks it can allocate.
+            /// It reserves enough virtual memory for <tt>block_size * no_blocks</tt>.
+            /// \requires \c block_size must be non-zero and a multiple of the \ref virtual_memory_page_size.
+            /// \c no_blocks must be bigger than \c 1.
+            /// \throws \ref out_of_memory if it cannot reserve the virtual memory.
+            explicit virtual_block_allocator(std::size_t block_size, std::size_t no_blocks);
+
+            /// \effects Releases the reserved virtual memory.
+            ~virtual_block_allocator() noexcept;
+
+            /// @{
+            /// \effects Moves the block allocator, it transfers ownership over the reserved area.
+            /// This does not invalidate any memory blocks.
+            virtual_block_allocator(virtual_block_allocator&& other) noexcept
+            : cur_(other.cur_), end_(other.end_), block_size_(other.block_size_)
+            {
+                other.cur_ = other.end_ = nullptr;
+                other.block_size_       = 0;
+            }
+
+            virtual_block_allocator& operator=(virtual_block_allocator&& other) noexcept
+            {
+                virtual_block_allocator tmp(detail::move(other));
+                swap(*this, tmp);
+                return *this;
+            }
+            /// @}
+
+            /// \effects Swaps the ownership over the reserved memory.
+            /// This does not invalidate any memory blocks.
+            friend void swap(virtual_block_allocator& a, virtual_block_allocator& b) noexcept
+            {
+                detail::adl_swap(a.cur_, b.cur_);
+                detail::adl_swap(a.end_, b.end_);
+                detail::adl_swap(a.block_size_, b.block_size_);
+            }
+
+            /// \effects Allocates a new memory block by committing the next \ref next_block_size() number of bytes.
+            /// \returns The \ref memory_block committed.
+            /// \throws \ref out_of_memory if it cannot commit the memory or the \ref capacity_left() is exhausted.
+            memory_block allocate_block();
+
+            /// \effects Deallocates the last allocated memory block by decommitting it.
+            /// This block will be returned again on the next call to \ref allocate_block().
+            /// \requires \c block must be the current top block of the memory,
+            /// this is guaranteed by \ref memory_arena.
+            void deallocate_block(memory_block block) noexcept;
+
+            /// \returns The next block size, this is the block size of the constructor.
+            std::size_t next_block_size() const noexcept
+            {
+                return block_size_;
+            }
+
+            /// \returns The number of blocks that can be committed until it runs out of memory.
+            std::size_t capacity_left() const noexcept
+            {
+                return static_cast<std::size_t>(end_ - cur_) / block_size_;
+            }
+
+        private:
+            allocator_info info() noexcept;
+
+            char *      cur_, *end_;
+            std::size_t block_size_;
+        };
+    } // namespace memory
+} // namespace wpi
+
+#endif //WPI_MEMORY_VIRTUAL_MEMORY_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/debugging.cpp b/wpiutil/src/main/native/thirdparty/memory/src/debugging.cpp
new file mode 100644
index 0000000..be1b033
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/debugging.cpp
@@ -0,0 +1,109 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/debugging.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <cstdio>
+#endif
+
+#include <atomic>
+#include <cstdlib>
+
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+
+namespace
+{
+    void default_leak_handler(const allocator_info& info, std::ptrdiff_t amount) noexcept
+    {
+#if WPI_HOSTED_IMPLEMENTATION
+        if (amount > 0)
+            std::fprintf(stderr, "[%s] Allocator %s (at %p) leaked %zu bytes.\n",
+                         WPI_MEMORY_LOG_PREFIX, info.name, info.allocator,
+                         std::size_t(amount));
+        else
+            std::fprintf(stderr,
+                         "[%s] Allocator %s (at %p) has deallocated %zu bytes more than "
+                         "ever allocated "
+                         "(it's amazing you're able to see this message!).\n",
+                         WPI_MEMORY_LOG_PREFIX, info.name, info.allocator,
+                         std::size_t(-amount));
+#else
+        (void)info;
+        (void)amount;
+#endif
+    }
+
+    std::atomic<leak_handler> leak_h(default_leak_handler);
+} // namespace
+
+leak_handler wpi::memory::set_leak_handler(leak_handler h)
+{
+    return leak_h.exchange(h ? h : default_leak_handler);
+}
+
+leak_handler wpi::memory::get_leak_handler()
+{
+    return leak_h;
+}
+
+namespace
+{
+    void default_invalid_ptr_handler(const allocator_info& info, const void* ptr) noexcept
+    {
+#if WPI_HOSTED_IMPLEMENTATION
+        std::fprintf(stderr,
+                     "[%s] Deallocation function of allocator %s (at %p) received invalid "
+                     "pointer %p\n",
+                     WPI_MEMORY_LOG_PREFIX, info.name, info.allocator, ptr);
+#endif
+        (void)info;
+        (void)ptr;
+        std::abort();
+    }
+
+    std::atomic<invalid_pointer_handler> invalid_ptr_h(default_invalid_ptr_handler);
+} // namespace
+
+invalid_pointer_handler wpi::memory::set_invalid_pointer_handler(invalid_pointer_handler h)
+{
+    return invalid_ptr_h.exchange(h ? h : default_invalid_ptr_handler);
+}
+
+invalid_pointer_handler wpi::memory::get_invalid_pointer_handler()
+{
+    return invalid_ptr_h;
+}
+
+namespace
+{
+    void default_buffer_overflow_handler(const void* memory, std::size_t node_size,
+                                         const void* ptr) noexcept
+    {
+#if WPI_HOSTED_IMPLEMENTATION
+        std::fprintf(stderr,
+                     "[%s] Buffer overflow at address %p detected, corresponding memory "
+                     "block %p has only size %zu.\n",
+                     WPI_MEMORY_LOG_PREFIX, ptr, memory, node_size);
+#endif
+        (void)memory;
+        (void)node_size;
+        (void)ptr;
+        std::abort();
+    }
+
+    std::atomic<buffer_overflow_handler> buffer_overflow_h(default_buffer_overflow_handler);
+} // namespace
+
+buffer_overflow_handler wpi::memory::set_buffer_overflow_handler(buffer_overflow_handler h)
+{
+    return buffer_overflow_h.exchange(h ? h : default_buffer_overflow_handler);
+}
+
+buffer_overflow_handler wpi::memory::get_buffer_overflow_handler()
+{
+    return buffer_overflow_h;
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/align.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/align.cpp
new file mode 100644
index 0000000..e1c4f2a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/align.cpp
@@ -0,0 +1,22 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/align.hpp"
+
+#include "wpi/memory/detail/ilog2.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+bool wpi::memory::detail::is_aligned(void* ptr, std::size_t alignment) noexcept
+{
+    WPI_MEMORY_ASSERT(is_valid_alignment(alignment));
+    auto address = reinterpret_cast<std::uintptr_t>(ptr);
+    return address % alignment == 0u;
+}
+
+std::size_t wpi::memory::detail::alignment_for(std::size_t size) noexcept
+{
+    return size >= max_alignment ? max_alignment : (std::size_t(1) << ilog2(size));
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/assert.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/assert.cpp
new file mode 100644
index 0000000..497f7f8
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/assert.cpp
@@ -0,0 +1,34 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/assert.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <cstdio>
+#endif
+
+#include <cstdlib>
+
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+void detail::handle_failed_assert(const char* msg, const char* file, int line,
+                                  const char* fnc) noexcept
+{
+#if WPI_HOSTED_IMPLEMENTATION
+    std::fprintf(stderr, "[%s] Assertion failure in function %s (%s:%d): %s.\n",
+                 WPI_MEMORY_LOG_PREFIX, fnc, file, line, msg);
+#endif
+    std::abort();
+}
+
+void detail::handle_warning(const char* msg, const char* file, int line, const char* fnc) noexcept
+{
+#if WPI_HOSTED_IMPLEMENTATION
+    std::fprintf(stderr, "[%s] Warning triggered in function %s (%s:%d): %s.\n",
+                 WPI_MEMORY_LOG_PREFIX, fnc, file, line, msg);
+#endif
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/debug_helpers.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/debug_helpers.cpp
new file mode 100644
index 0000000..b5afb20
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/debug_helpers.cpp
@@ -0,0 +1,87 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/debug_helpers.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <cstring>
+#endif
+
+#include "wpi/memory/debugging.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+#if WPI_MEMORY_DEBUG_FILL
+void detail::debug_fill(void* memory, std::size_t size, debug_magic m) noexcept
+{
+#if WPI_HOSTED_IMPLEMENTATION
+    std::memset(memory, static_cast<int>(m), size);
+#else
+    // do the naive loop :(
+    auto ptr = static_cast<unsigned char*>(memory);
+    for (std::size_t i = 0u; i != size; ++i)
+        *ptr++ = static_cast<unsigned char>(m);
+#endif
+}
+
+void* detail::debug_is_filled(void* memory, std::size_t size, debug_magic m) noexcept
+{
+    auto byte = static_cast<unsigned char*>(memory);
+    for (auto end = byte + size; byte != end; ++byte)
+        if (*byte != static_cast<unsigned char>(m))
+            return byte;
+    return nullptr;
+}
+
+void* detail::debug_fill_new(void* memory, std::size_t node_size, std::size_t fence_size) noexcept
+{
+    if (!debug_fence_size)
+        fence_size = 0u; // force override of fence_size
+
+    auto mem = static_cast<char*>(memory);
+    debug_fill(mem, fence_size, debug_magic::fence_memory);
+
+    mem += fence_size;
+    debug_fill(mem, node_size, debug_magic::new_memory);
+
+    debug_fill(mem + node_size, fence_size, debug_magic::fence_memory);
+
+    return mem;
+}
+
+void* detail::debug_fill_free(void* memory, std::size_t node_size, std::size_t fence_size) noexcept
+{
+    if (!debug_fence_size)
+        fence_size = 0u; // force override of fence_size
+
+    debug_fill(memory, node_size, debug_magic::freed_memory);
+
+    auto pre_fence = static_cast<unsigned char*>(memory) - fence_size;
+    if (auto pre_dirty = debug_is_filled(pre_fence, fence_size, debug_magic::fence_memory))
+        get_buffer_overflow_handler()(memory, node_size, pre_dirty);
+
+    auto post_mem = static_cast<unsigned char*>(memory) + node_size;
+    if (auto post_dirty = debug_is_filled(post_mem, fence_size, debug_magic::fence_memory))
+        get_buffer_overflow_handler()(memory, node_size, post_dirty);
+
+    return pre_fence;
+}
+
+void detail::debug_fill_internal(void* memory, std::size_t size, bool free) noexcept
+{
+    debug_fill(memory, size,
+               free ? debug_magic::internal_freed_memory : debug_magic::internal_memory);
+}
+#endif
+
+void detail::debug_handle_invalid_ptr(const allocator_info& info, void* ptr)
+{
+    get_invalid_pointer_handler()(info, ptr);
+}
+
+void detail::debug_handle_memory_leak(const allocator_info& info, std::ptrdiff_t amount)
+{
+    get_leak_handler()(info, amount);
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list.cpp
new file mode 100644
index 0000000..2ca7034
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list.cpp
@@ -0,0 +1,557 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/free_list.hpp"
+
+#include "wpi/memory/detail/align.hpp"
+#include "wpi/memory/detail/debug_helpers.hpp"
+#include "wpi/memory/detail/assert.hpp"
+#include "wpi/memory/debugging.hpp"
+#include "wpi/memory/error.hpp"
+
+#include "free_list_utils.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+namespace
+{
+    // i.e. array
+    struct interval
+    {
+        char* prev;  // last before
+        char* first; // first in
+        char* last;  // last in
+        char* next;  // first after
+
+        // number of nodes in the interval
+        std::size_t size(std::size_t node_size) const noexcept
+        {
+            // last is inclusive, so add actual_size to it
+            // note: cannot use next, might not be directly after
+            auto end = last + node_size;
+            WPI_MEMORY_ASSERT(static_cast<std::size_t>(end - first) % node_size == 0u);
+            return static_cast<std::size_t>(end - first) / node_size;
+        }
+    };
+
+    // searches for n consecutive bytes
+    // begin and end are the proxy nodes
+    // assumes list is not empty
+    // similar to list_search_array()
+    interval list_search_array(char* first, std::size_t bytes_needed,
+                               std::size_t node_size) noexcept
+    {
+        interval i;
+        i.prev  = nullptr;
+        i.first = first;
+        // i.last/next are used as iterator for the end of the interval
+        i.last = first;
+        i.next = list_get_next(first);
+
+        auto bytes_so_far = node_size;
+        while (i.next)
+        {
+            if (i.last + node_size != i.next) // not continous
+            {
+                // restart at next
+                i.prev  = i.last;
+                i.first = i.next;
+                i.last  = i.next;
+                i.next  = list_get_next(i.last);
+
+                bytes_so_far = node_size;
+            }
+            else
+            {
+                // extend interval
+                auto new_next = list_get_next(i.next);
+                i.last        = i.next;
+                i.next        = new_next;
+
+                bytes_so_far += node_size;
+                if (bytes_so_far >= bytes_needed)
+                    return i;
+            }
+        }
+        // not enough continuous space
+        return {nullptr, nullptr, nullptr, nullptr};
+    }
+
+    // similar to list_search_array()
+    // begin/end are proxy nodes
+    interval xor_list_search_array(char* begin, char* end, std::size_t bytes_needed,
+                                   std::size_t node_size) noexcept
+    {
+        interval i;
+        i.prev  = begin;
+        i.first = xor_list_get_other(begin, nullptr);
+        // i.last/next are used as iterator for the end of the interval
+        i.last = i.first;
+        i.next = xor_list_get_other(i.last, i.prev);
+
+        auto bytes_so_far = node_size;
+        while (i.next != end)
+        {
+            if (i.last + node_size != i.next) // not continous
+            {
+                // restart at i.next
+                i.prev  = i.last;
+                i.first = i.next;
+                i.last  = i.next;
+                i.next  = xor_list_get_other(i.first, i.prev);
+
+                bytes_so_far = node_size;
+            }
+            else
+            {
+                // extend interval
+                auto new_next = xor_list_get_other(i.next, i.last);
+                i.last        = i.next;
+                i.next        = new_next;
+
+                bytes_so_far += node_size;
+                if (bytes_so_far >= bytes_needed)
+                    return i;
+            }
+        }
+        // not enough continuous space
+        return {nullptr, nullptr, nullptr, nullptr};
+    }
+} // namespace
+
+constexpr std::size_t free_memory_list::min_element_size;
+constexpr std::size_t free_memory_list::min_element_alignment;
+
+free_memory_list::free_memory_list(std::size_t node_size) noexcept
+: first_(nullptr),
+  node_size_(node_size > min_element_size ? node_size : min_element_size),
+  capacity_(0u)
+{
+}
+
+free_memory_list::free_memory_list(std::size_t node_size, void* mem, std::size_t size) noexcept
+: free_memory_list(node_size)
+{
+    insert(mem, size);
+}
+
+free_memory_list::free_memory_list(free_memory_list&& other) noexcept
+: first_(other.first_), node_size_(other.node_size_), capacity_(other.capacity_)
+{
+    other.first_    = nullptr;
+    other.capacity_ = 0u;
+}
+
+free_memory_list& free_memory_list::operator=(free_memory_list&& other) noexcept
+{
+    free_memory_list tmp(detail::move(other));
+    swap(*this, tmp);
+    return *this;
+}
+
+void wpi::memory::detail::swap(free_memory_list& a, free_memory_list& b) noexcept
+{
+    detail::adl_swap(a.first_, b.first_);
+    detail::adl_swap(a.node_size_, b.node_size_);
+    detail::adl_swap(a.capacity_, b.capacity_);
+}
+
+void free_memory_list::insert(void* mem, std::size_t size) noexcept
+{
+    WPI_MEMORY_ASSERT(mem);
+    WPI_MEMORY_ASSERT(is_aligned(mem, alignment()));
+    detail::debug_fill_internal(mem, size, false);
+
+    insert_impl(mem, size);
+}
+
+void* free_memory_list::allocate() noexcept
+{
+    WPI_MEMORY_ASSERT(!empty());
+    --capacity_;
+
+    auto mem = first_;
+    first_   = list_get_next(first_);
+    return detail::debug_fill_new(mem, node_size_, 0);
+}
+
+void* free_memory_list::allocate(std::size_t n) noexcept
+{
+    WPI_MEMORY_ASSERT(!empty());
+    if (n <= node_size_)
+        return allocate();
+
+    auto i = list_search_array(first_, n, node_size_);
+    if (i.first == nullptr)
+        return nullptr;
+
+    if (i.prev)
+        list_set_next(i.prev, i.next); // change next from previous to first after
+    else
+        first_ = i.next;
+    capacity_ -= i.size(node_size_);
+
+    return detail::debug_fill_new(i.first, n, 0);
+}
+
+void free_memory_list::deallocate(void* ptr) noexcept
+{
+    ++capacity_;
+
+    auto node = static_cast<char*>(detail::debug_fill_free(ptr, node_size_, 0));
+    list_set_next(node, first_);
+    first_ = node;
+}
+
+void free_memory_list::deallocate(void* ptr, std::size_t n) noexcept
+{
+    if (n <= node_size_)
+        deallocate(ptr);
+    else
+    {
+        auto mem = detail::debug_fill_free(ptr, n, 0);
+        insert_impl(mem, n);
+    }
+}
+
+std::size_t free_memory_list::alignment() const noexcept
+{
+    return alignment_for(node_size_);
+}
+
+void free_memory_list::insert_impl(void* mem, std::size_t size) noexcept
+{
+    auto no_nodes = size / node_size_;
+    WPI_MEMORY_ASSERT(no_nodes > 0);
+
+    auto cur = static_cast<char*>(mem);
+    for (std::size_t i = 0u; i != no_nodes - 1; ++i)
+    {
+        list_set_next(cur, cur + node_size_);
+        cur += node_size_;
+    }
+    list_set_next(cur, first_);
+    first_ = static_cast<char*>(mem);
+
+    capacity_ += no_nodes;
+}
+
+namespace
+{
+    // converts a block into a linked list
+    void xor_link_block(void* memory, std::size_t node_size, std::size_t no_nodes, char* prev,
+                        char* next) noexcept
+    {
+        auto cur = static_cast<char*>(memory);
+        xor_list_change(prev, next, cur); // change next pointer of prev
+
+        auto last_cur = prev;
+        for (std::size_t i = 0u; i != no_nodes - 1; ++i)
+        {
+            xor_list_set(cur, last_cur,
+                         cur + node_size); // cur gets last_cur and next node in continous memory
+            last_cur = cur;
+            cur += node_size;
+        }
+        xor_list_set(cur, last_cur, next); // last memory node gets next as next
+        xor_list_change(next, prev, cur);  // change prev pointer of next
+    }
+
+    struct pos
+    {
+        char *prev, *next;
+    };
+
+    // finds position to insert memory to keep list ordered
+    // first_prev -> first -> ... (memory somewhere here) ... -> last -> last_next
+    pos find_pos_interval(const allocator_info& info, char* memory, char* first_prev, char* first,
+                          char* last, char* last_next) noexcept
+    {
+        // note: first_prev/last_next can be the proxy nodes, then first_prev isn't necessarily less than first!
+        WPI_MEMORY_ASSERT(less(first, memory) && less(memory, last));
+
+        // need to insert somewhere in the middle
+        // search through the entire list
+        // search from both ends at once
+        auto cur_forward  = first;
+        auto prev_forward = first_prev;
+
+        auto cur_backward  = last;
+        auto prev_backward = last_next;
+
+        do
+        {
+            if (greater(cur_forward, memory))
+                return {prev_forward, cur_forward};
+            else if (less(cur_backward, memory))
+                // the next position is the previous backwards pointer
+                return {cur_backward, prev_backward};
+            debug_check_double_dealloc([&]
+                                       { return cur_forward != memory && cur_backward != memory; },
+                                       info, memory);
+            xor_list_iter_next(cur_forward, prev_forward);
+            xor_list_iter_next(cur_backward, prev_backward);
+        } while (less(prev_forward, prev_backward));
+
+        // ran outside of list
+        debug_check_double_dealloc([] { return false; }, info, memory);
+        return {nullptr, nullptr};
+    }
+
+    // finds the position in the entire list
+    pos find_pos(const allocator_info& info, char* memory, char* begin_node, char* end_node,
+                 char* last_dealloc, char* last_dealloc_prev) noexcept
+    {
+        auto first = xor_list_get_other(begin_node, nullptr);
+        auto last  = xor_list_get_other(end_node, nullptr);
+
+        if (greater(first, memory))
+            // insert at front
+            return {begin_node, first};
+        else if (less(last, memory))
+            // insert at the end
+            return {last, end_node};
+        else if (less(last_dealloc_prev, memory) && less(memory, last_dealloc))
+            // insert before last_dealloc
+            return {last_dealloc_prev, last_dealloc};
+        else if (less(memory, last_dealloc))
+            // insert into [first, last_dealloc_prev]
+            return find_pos_interval(info, memory, begin_node, first, last_dealloc_prev,
+                                     last_dealloc);
+        else if (greater(memory, last_dealloc))
+            // insert into (last_dealloc, last]
+            return find_pos_interval(info, memory, last_dealloc_prev, last_dealloc, last, end_node);
+
+        WPI_MEMORY_UNREACHABLE("memory must be in some half or outside");
+        return {nullptr, nullptr};
+    }
+} // namespace
+
+constexpr std::size_t ordered_free_memory_list::min_element_size;
+constexpr std::size_t ordered_free_memory_list::min_element_alignment;
+
+ordered_free_memory_list::ordered_free_memory_list(std::size_t node_size) noexcept
+: node_size_(node_size > min_element_size ? node_size : min_element_size),
+  capacity_(0u),
+  last_dealloc_(end_node()),
+  last_dealloc_prev_(begin_node())
+{
+    xor_list_set(begin_node(), nullptr, end_node());
+    xor_list_set(end_node(), begin_node(), nullptr);
+}
+
+ordered_free_memory_list::ordered_free_memory_list(ordered_free_memory_list&& other) noexcept
+: node_size_(other.node_size_), capacity_(other.capacity_)
+{
+    if (!other.empty())
+    {
+        auto first = xor_list_get_other(other.begin_node(), nullptr);
+        auto last  = xor_list_get_other(other.end_node(), nullptr);
+
+        xor_list_set(begin_node(), nullptr, first);
+        xor_list_change(first, other.begin_node(), begin_node());
+        xor_list_change(last, other.end_node(), end_node());
+        xor_list_set(end_node(), last, nullptr);
+
+        other.capacity_ = 0u;
+        xor_list_set(other.begin_node(), nullptr, other.end_node());
+        xor_list_set(other.end_node(), other.begin_node(), nullptr);
+    }
+    else
+    {
+        xor_list_set(begin_node(), nullptr, end_node());
+        xor_list_set(end_node(), begin_node(), nullptr);
+    }
+
+    // for programming convenience, last_dealloc is reset
+    last_dealloc_prev_ = begin_node();
+    last_dealloc_      = xor_list_get_other(last_dealloc_prev_, nullptr);
+}
+
+void wpi::memory::detail::swap(ordered_free_memory_list& a,
+                                     ordered_free_memory_list& b) noexcept
+{
+    auto a_first = xor_list_get_other(a.begin_node(), nullptr);
+    auto a_last  = xor_list_get_other(a.end_node(), nullptr);
+
+    auto b_first = xor_list_get_other(b.begin_node(), nullptr);
+    auto b_last  = xor_list_get_other(b.end_node(), nullptr);
+
+    if (!a.empty())
+    {
+        xor_list_set(b.begin_node(), nullptr, a_first);
+        xor_list_change(a_first, a.begin_node(), b.begin_node());
+        xor_list_change(a_last, a.end_node(), b.end_node());
+        xor_list_set(b.end_node(), a_last, nullptr);
+    }
+    else
+    {
+        xor_list_set(b.begin_node(), nullptr, b.end_node());
+        xor_list_set(b.end_node(), b.begin_node(), nullptr);
+    }
+
+    if (!b.empty())
+    {
+        xor_list_set(a.begin_node(), nullptr, b_first);
+        xor_list_change(b_first, b.begin_node(), a.begin_node());
+        xor_list_change(b_last, b.end_node(), a.end_node());
+        xor_list_set(a.end_node(), b_last, nullptr);
+    }
+    else
+    {
+        xor_list_set(a.begin_node(), nullptr, a.end_node());
+        xor_list_set(a.end_node(), a.begin_node(), nullptr);
+    }
+
+    detail::adl_swap(a.node_size_, b.node_size_);
+    detail::adl_swap(a.capacity_, b.capacity_);
+
+    // for programming convenience, last_dealloc is reset
+    a.last_dealloc_prev_ = a.begin_node();
+    a.last_dealloc_      = xor_list_get_other(a.last_dealloc_prev_, nullptr);
+
+    b.last_dealloc_prev_ = b.begin_node();
+    b.last_dealloc_      = xor_list_get_other(b.last_dealloc_prev_, nullptr);
+}
+
+void ordered_free_memory_list::insert(void* mem, std::size_t size) noexcept
+{
+    WPI_MEMORY_ASSERT(mem);
+    WPI_MEMORY_ASSERT(is_aligned(mem, alignment()));
+    detail::debug_fill_internal(mem, size, false);
+
+    insert_impl(mem, size);
+}
+
+void* ordered_free_memory_list::allocate() noexcept
+{
+    WPI_MEMORY_ASSERT(!empty());
+
+    // remove first node
+    auto prev = begin_node();
+    auto node = xor_list_get_other(prev, nullptr);
+    auto next = xor_list_get_other(node, prev);
+
+    xor_list_set(prev, nullptr, next); // link prev to next
+    xor_list_change(next, node, prev); // change prev of next
+    --capacity_;
+
+    if (node == last_dealloc_)
+    {
+        // move last_dealloc_ one further in
+        last_dealloc_ = next;
+        WPI_MEMORY_ASSERT(last_dealloc_prev_ == prev);
+    }
+    else if (node == last_dealloc_prev_)
+    {
+        // now the previous node is the node before ours
+        last_dealloc_prev_ = prev;
+        WPI_MEMORY_ASSERT(last_dealloc_ == next);
+    }
+
+    return detail::debug_fill_new(node, node_size_, 0);
+}
+
+void* ordered_free_memory_list::allocate(std::size_t n) noexcept
+{
+    WPI_MEMORY_ASSERT(!empty());
+
+    if (n <= node_size_)
+        return allocate();
+
+    auto i = xor_list_search_array(begin_node(), end_node(), n, node_size_);
+    if (i.first == nullptr)
+        return nullptr;
+
+    xor_list_change(i.prev, i.first, i.next); // change next pointer from i.prev to i.next
+    xor_list_change(i.next, i.last, i.prev);  // change prev pointer from i.next to i.prev
+    capacity_ -= i.size(node_size_);
+
+    // if last_dealloc_ points into the array being removed
+    if ((less_equal(i.first, last_dealloc_) && less_equal(last_dealloc_, i.last)))
+    {
+        // move last_dealloc just outside range
+        last_dealloc_      = i.next;
+        last_dealloc_prev_ = i.prev;
+    }
+    // if the previous deallocation is the last element of the array
+    else if (last_dealloc_prev_ == i.last)
+    {
+        // it is now the last element before the array
+        WPI_MEMORY_ASSERT(last_dealloc_ == i.next);
+        last_dealloc_prev_ = i.prev;
+    }
+
+    return detail::debug_fill_new(i.first, n, 0);
+}
+
+void ordered_free_memory_list::deallocate(void* ptr) noexcept
+{
+    auto node = static_cast<char*>(debug_fill_free(ptr, node_size_, 0));
+
+    auto p =
+        find_pos(allocator_info(WPI_MEMORY_LOG_PREFIX "::detail::ordered_free_memory_list",
+                                this),
+                 node, begin_node(), end_node(), last_dealloc_, last_dealloc_prev_);
+
+    xor_list_insert(node, p.prev, p.next);
+    ++capacity_;
+
+    last_dealloc_      = node;
+    last_dealloc_prev_ = p.prev;
+}
+
+void ordered_free_memory_list::deallocate(void* ptr, std::size_t n) noexcept
+{
+    if (n <= node_size_)
+        deallocate(ptr);
+    else
+    {
+        auto mem  = detail::debug_fill_free(ptr, n, 0);
+        auto prev = insert_impl(mem, n);
+
+        last_dealloc_      = static_cast<char*>(mem);
+        last_dealloc_prev_ = prev;
+    }
+}
+
+std::size_t ordered_free_memory_list::alignment() const noexcept
+{
+    return alignment_for(node_size_);
+}
+
+char* ordered_free_memory_list::insert_impl(void* mem, std::size_t size) noexcept
+{
+    auto no_nodes = size / node_size_;
+    WPI_MEMORY_ASSERT(no_nodes > 0);
+
+    auto p =
+        find_pos(allocator_info(WPI_MEMORY_LOG_PREFIX "::detail::ordered_free_memory_list",
+                                this),
+                 static_cast<char*>(mem), begin_node(), end_node(), last_dealloc_,
+                 last_dealloc_prev_);
+
+    xor_link_block(mem, node_size_, no_nodes, p.prev, p.next);
+    capacity_ += no_nodes;
+
+    if (p.prev == last_dealloc_prev_)
+    {
+        last_dealloc_ = static_cast<char*>(mem);
+    }
+
+    return p.prev;
+}
+
+char* ordered_free_memory_list::begin_node() noexcept
+{
+    void* mem = &begin_proxy_;
+    return static_cast<char*>(mem);
+}
+
+char* ordered_free_memory_list::end_node() noexcept
+{
+    void* mem = &end_proxy_;
+    return static_cast<char*>(mem);
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_array.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_array.cpp
new file mode 100644
index 0000000..f4658da
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_array.cpp
@@ -0,0 +1,22 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/free_list_array.hpp"
+
+#include "wpi/memory/detail/assert.hpp"
+#include "wpi/memory/detail/ilog2.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+std::size_t log2_access_policy::index_from_size(std::size_t size) noexcept
+{
+    WPI_MEMORY_ASSERT_MSG(size, "size must not be zero");
+    return ilog2_ceil(size);
+}
+
+std::size_t log2_access_policy::size_from_index(std::size_t index) noexcept
+{
+    return std::size_t(1) << index;
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_utils.hpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_utils.hpp
new file mode 100644
index 0000000..a752837
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/free_list_utils.hpp
@@ -0,0 +1,149 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#ifndef WPI_MEMORY_SRC_DETAIL_FREE_LIST_UTILS_HPP_INCLUDED
+#define WPI_MEMORY_SRC_DETAIL_FREE_LIST_UTILS_HPP_INCLUDED
+
+#include <cstdint>
+
+#include "wpi/memory/config.hpp"
+#include "wpi/memory/detail/align.hpp"
+#include "wpi/memory/detail/assert.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <cstring>
+#include <functional>
+#endif
+
+namespace wpi
+{
+    namespace memory
+    {
+        namespace detail
+        {
+            //=== storage ===///
+            // reads stored integer value
+            inline std::uintptr_t get_int(void* address) noexcept
+            {
+                WPI_MEMORY_ASSERT(address);
+                std::uintptr_t res;
+#if WPI_HOSTED_IMPLEMENTATION
+                std::memcpy(&res, address, sizeof(std::uintptr_t));
+#else
+                auto mem = static_cast<char*>(static_cast<void*>(&res));
+                for (auto i = 0u; i != sizeof(std::uintptr_t); ++i)
+                    mem[i] = static_cast<char*>(address)[i];
+#endif
+                return res;
+            }
+
+            // sets stored integer value
+            inline void set_int(void* address, std::uintptr_t i) noexcept
+            {
+                WPI_MEMORY_ASSERT(address);
+#if WPI_HOSTED_IMPLEMENTATION
+                std::memcpy(address, &i, sizeof(std::uintptr_t));
+#else
+                auto mem = static_cast<char*>(static_cast<void*>(&i));
+                for (auto i = 0u; i != sizeof(std::uintptr_t); ++i)
+                    static_cast<char*>(address)[i] = mem[i];
+#endif
+            }
+
+            // pointer to integer
+            inline std::uintptr_t to_int(char* ptr) noexcept
+            {
+                return reinterpret_cast<std::uintptr_t>(ptr);
+            }
+
+            // integer to pointer
+            inline char* from_int(std::uintptr_t i) noexcept
+            {
+                return reinterpret_cast<char*>(i);
+            }
+
+            //=== intrusive linked list ===//
+            // reads a stored pointer value
+            inline char* list_get_next(void* address) noexcept
+            {
+                return from_int(get_int(address));
+            }
+
+            // stores a pointer value
+            inline void list_set_next(void* address, char* ptr) noexcept
+            {
+                set_int(address, to_int(ptr));
+            }
+
+            //=== intrusive xor linked list ===//
+            // returns the other pointer given one pointer
+            inline char* xor_list_get_other(void* address, char* prev_or_next) noexcept
+            {
+                return from_int(get_int(address) ^ to_int(prev_or_next));
+            }
+
+            // sets the next and previous pointer (order actually does not matter)
+            inline void xor_list_set(void* address, char* prev, char* next) noexcept
+            {
+                set_int(address, to_int(prev) ^ to_int(next));
+            }
+
+            // changes other pointer given one pointer
+            inline void xor_list_change(void* address, char* old_ptr, char* new_ptr) noexcept
+            {
+                WPI_MEMORY_ASSERT(address);
+                auto other = xor_list_get_other(address, old_ptr);
+                xor_list_set(address, other, new_ptr);
+            }
+
+            // advances a pointer pair forward/backward
+            inline void xor_list_iter_next(char*& cur, char*& prev) noexcept
+            {
+                auto next = xor_list_get_other(cur, prev);
+                prev      = cur;
+                cur       = next;
+            }
+
+            // links new node between prev and next
+            inline void xor_list_insert(char* new_node, char* prev, char* next) noexcept
+            {
+                xor_list_set(new_node, prev, next);
+                xor_list_change(prev, next, new_node); // change prev's next to new_node
+                xor_list_change(next, prev, new_node); // change next's prev to new_node
+            }
+
+            //=== sorted list utils ===//
+            // if std::less/std::greater not available compare integer representation and hope it works
+            inline bool less(void* a, void* b) noexcept
+            {
+#if WPI_HOSTED_IMPLEMENTATION
+                return std::less<void*>()(a, b);
+#else
+                return to_int(a) < to_int(b);
+#endif
+            }
+
+            inline bool less_equal(void* a, void* b) noexcept
+            {
+                return a == b || less(a, b);
+            }
+
+            inline bool greater(void* a, void* b) noexcept
+            {
+#if WPI_HOSTED_IMPLEMENTATION
+                return std::greater<void*>()(a, b);
+#else
+                return to_int(a) < to_int(b);
+#endif
+            }
+
+            inline bool greater_equal(void* a, void* b) noexcept
+            {
+                return a == b || greater(a, b);
+            }
+        } // namespace detail
+    }     // namespace memory
+} // namespace wpi
+
+#endif // WPI_MEMORY_SRC_DETAIL_FREE_LIST_UTILS_HPP_INCLUDED
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/detail/small_free_list.cpp b/wpiutil/src/main/native/thirdparty/memory/src/detail/small_free_list.cpp
new file mode 100644
index 0000000..3508daa
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/detail/small_free_list.cpp
@@ -0,0 +1,395 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/detail/small_free_list.hpp"
+
+#include <new>
+
+#include "wpi/memory/detail/debug_helpers.hpp"
+#include "wpi/memory/detail/assert.hpp"
+#include "wpi/memory/error.hpp"
+
+#include "free_list_utils.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+struct wpi::memory::detail::chunk : chunk_base
+{
+    // gives it the size of the memory block it is created in and the size of a node
+    chunk(std::size_t total_memory, std::size_t node_size) noexcept
+    : chunk_base(static_cast<unsigned char>((total_memory - chunk_memory_offset) / node_size))
+    {
+        static_assert(sizeof(chunk) == sizeof(chunk_base), "chunk must not have members");
+        WPI_MEMORY_ASSERT((total_memory - chunk_memory_offset) / node_size
+                                <= chunk_max_nodes);
+        WPI_MEMORY_ASSERT(capacity > 0);
+        auto p = list_memory();
+        for (unsigned char i = 0u; i != no_nodes; p += node_size)
+            *p = ++i;
+    }
+
+    // returns memory of the free list
+    unsigned char* list_memory() noexcept
+    {
+        auto mem = static_cast<void*>(this);
+        return static_cast<unsigned char*>(mem) + chunk_memory_offset;
+    }
+
+    // returns the nth node
+    unsigned char* node_memory(unsigned char i, std::size_t node_size) noexcept
+    {
+        WPI_MEMORY_ASSERT(i < no_nodes);
+        return list_memory() + i * node_size;
+    }
+
+    // checks whether a node came from this chunk
+    bool from(unsigned char* node, std::size_t node_size) noexcept
+    {
+        auto begin = list_memory();
+        auto end   = list_memory() + no_nodes * node_size;
+        return (begin <= node) & (node < end);
+    }
+
+    // checks whether a node is already in this chunk
+    bool contains(unsigned char* node, std::size_t node_size) noexcept
+    {
+        auto cur_index = first_free;
+        while (cur_index != no_nodes)
+        {
+            auto cur_mem = node_memory(cur_index, node_size);
+            if (cur_mem == node)
+                return true;
+            cur_index = *cur_mem;
+        }
+        return false;
+    }
+
+    // allocates a single node
+    // chunk most not be empty
+    unsigned char* allocate(std::size_t node_size) noexcept
+    {
+        --capacity;
+
+        auto node  = node_memory(first_free, node_size);
+        first_free = *node;
+        return node;
+    }
+
+    // deallocates a single node given its address and index
+    // it must be from this chunk
+    void deallocate(unsigned char* node, unsigned char node_index) noexcept
+    {
+        ++capacity;
+
+        *node      = first_free;
+        first_free = node_index;
+    }
+};
+
+namespace
+{
+    // converts a chunk_base to a chunk (if it is one)
+    chunk* make_chunk(chunk_base* c) noexcept
+    {
+        return static_cast<chunk*>(c);
+    }
+
+    // same as above but also requires a certain size
+    chunk* make_chunk(chunk_base* c, std::size_t size_needed) noexcept
+    {
+        WPI_MEMORY_ASSERT(size_needed <= chunk_max_nodes);
+        return c->capacity >= size_needed ? make_chunk(c) : nullptr;
+    }
+
+    // checks if memory was from a chunk, assumes chunk isn't proxy
+    chunk* from_chunk(chunk_base* c, unsigned char* node, std::size_t node_size) noexcept
+    {
+        auto res = make_chunk(c);
+        return res->from(node, node_size) ? res : nullptr;
+    }
+
+    // inserts already interconnected chunks into the list
+    // list will be kept ordered
+    void insert_chunks(chunk_base* list, chunk_base* begin, chunk_base* end) noexcept
+    {
+        WPI_MEMORY_ASSERT(begin && end);
+
+        if (list->next == list) // empty
+        {
+            begin->prev = list;
+            end->next   = list->next;
+            list->next  = begin;
+            list->prev  = end;
+        }
+        else if (less(list->prev, begin)) // insert at end
+        {
+            list->prev->next = begin;
+            begin->prev      = list->prev;
+            end->next        = list;
+            list->prev       = end;
+        }
+        else
+        {
+            auto prev = list;
+            auto cur  = list->next;
+            while (less(cur, begin))
+            {
+                prev = cur;
+                cur  = cur->next;
+            }
+            WPI_MEMORY_ASSERT(greater(cur, end));
+            WPI_MEMORY_ASSERT(prev == list || less(prev, begin));
+            prev->next  = begin;
+            begin->prev = prev;
+            end->next   = cur;
+            cur->prev   = end;
+        }
+    }
+} // namespace
+
+constexpr std::size_t small_free_memory_list::min_element_size;
+constexpr std::size_t small_free_memory_list::min_element_alignment;
+
+small_free_memory_list::small_free_memory_list(std::size_t node_size) noexcept
+: node_size_(node_size), capacity_(0u), alloc_chunk_(&base_), dealloc_chunk_(&base_)
+{
+}
+
+small_free_memory_list::small_free_memory_list(std::size_t node_size, void* mem,
+                                               std::size_t size) noexcept
+: small_free_memory_list(node_size)
+{
+    insert(mem, size);
+}
+
+small_free_memory_list::small_free_memory_list(small_free_memory_list&& other) noexcept
+: node_size_(other.node_size_),
+  capacity_(other.capacity_),
+  // reset markers for simplicity
+  alloc_chunk_(&base_),
+  dealloc_chunk_(&base_)
+{
+    if (!other.empty())
+    {
+        base_.next             = other.base_.next;
+        base_.prev             = other.base_.prev;
+        other.base_.next->prev = &base_;
+        other.base_.prev->next = &base_;
+
+        other.base_.next = &other.base_;
+        other.base_.prev = &other.base_;
+        other.capacity_  = 0u;
+    }
+    else
+    {
+        base_.next = &base_;
+        base_.prev = &base_;
+    }
+}
+
+void wpi::memory::detail::swap(small_free_memory_list& a, small_free_memory_list& b) noexcept
+{
+    auto b_next = b.base_.next;
+    auto b_prev = b.base_.prev;
+
+    if (!a.empty())
+    {
+        b.base_.next       = a.base_.next;
+        b.base_.prev       = a.base_.prev;
+        b.base_.next->prev = &b.base_;
+        b.base_.prev->next = &b.base_;
+    }
+    else
+    {
+        b.base_.next = &b.base_;
+        b.base_.prev = &b.base_;
+    }
+
+    if (!b.empty())
+    {
+        a.base_.next       = b_next;
+        a.base_.prev       = b_prev;
+        a.base_.next->prev = &a.base_;
+        a.base_.prev->next = &a.base_;
+    }
+    else
+    {
+        a.base_.next = &a.base_;
+        a.base_.prev = &a.base_;
+    }
+
+    detail::adl_swap(a.node_size_, b.node_size_);
+    detail::adl_swap(a.capacity_, b.capacity_);
+
+    // reset markers for simplicity
+    a.alloc_chunk_ = a.dealloc_chunk_ = &a.base_;
+    b.alloc_chunk_ = b.dealloc_chunk_ = &b.base_;
+}
+
+void small_free_memory_list::insert(void* mem, std::size_t size) noexcept
+{
+    WPI_MEMORY_ASSERT(mem);
+    WPI_MEMORY_ASSERT(is_aligned(mem, max_alignment));
+    debug_fill_internal(mem, size, false);
+
+    auto total_chunk_size = chunk_memory_offset + node_size_ * chunk_max_nodes;
+    auto align_buffer     = align_offset(total_chunk_size, alignof(chunk));
+
+    auto no_chunks = size / (total_chunk_size + align_buffer);
+    auto remainder = size % (total_chunk_size + align_buffer);
+
+    auto memory          = static_cast<char*>(mem);
+    auto construct_chunk = [&](std::size_t total_memory, std::size_t node_size)
+    {
+        WPI_MEMORY_ASSERT(align_offset(memory, alignof(chunk)) == 0);
+        return ::new (static_cast<void*>(memory)) chunk(total_memory, node_size);
+    };
+
+    auto prev = static_cast<chunk_base*>(nullptr);
+    for (auto i = std::size_t(0); i != no_chunks; ++i)
+    {
+        auto c = construct_chunk(total_chunk_size, node_size_);
+
+        c->prev = prev;
+        if (prev)
+            prev->next = c;
+        prev = c;
+
+        memory += total_chunk_size;
+        memory += align_buffer;
+    }
+
+    auto new_nodes = no_chunks * chunk_max_nodes;
+    if (remainder >= chunk_memory_offset + node_size_) // at least one node
+    {
+        auto c = construct_chunk(remainder, node_size_);
+
+        c->prev = prev;
+        if (prev)
+            prev->next = c;
+        prev = c;
+
+        new_nodes += c->no_nodes;
+    }
+
+    WPI_MEMORY_ASSERT_MSG(new_nodes > 0, "memory block too small");
+    insert_chunks(&base_, static_cast<chunk_base*>(mem), prev);
+    capacity_ += new_nodes;
+}
+
+std::size_t small_free_memory_list::usable_size(std::size_t size) const noexcept
+{
+    auto total_chunk_size = chunk_memory_offset + node_size_ * chunk_max_nodes;
+    auto no_chunks        = size / total_chunk_size;
+    auto remainder        = size % total_chunk_size;
+
+    return no_chunks * chunk_max_nodes * node_size_
+           + (remainder > chunk_memory_offset ? remainder - chunk_memory_offset : 0u);
+}
+
+void* small_free_memory_list::allocate() noexcept
+{
+    auto chunk   = find_chunk_impl(1);
+    alloc_chunk_ = chunk;
+    WPI_MEMORY_ASSERT(chunk && chunk->capacity >= 1);
+
+    --capacity_;
+
+    auto mem = chunk->allocate(node_size_);
+    WPI_MEMORY_ASSERT(mem);
+    return detail::debug_fill_new(mem, node_size_, 0);
+}
+
+void small_free_memory_list::deallocate(void* mem) noexcept
+{
+    auto info =
+        allocator_info(WPI_MEMORY_LOG_PREFIX "::detail::small_free_memory_list", this);
+
+    auto node = static_cast<unsigned char*>(detail::debug_fill_free(mem, node_size_, 0));
+
+    auto chunk     = find_chunk_impl(node);
+    dealloc_chunk_ = chunk;
+    // memory was never allocated from list
+    detail::debug_check_pointer([&] { return chunk != nullptr; }, info, mem);
+
+    auto offset = static_cast<std::size_t>(node - chunk->list_memory());
+    // memory is not at the right position
+    debug_check_pointer([&] { return offset % node_size_ == 0u; }, info, mem);
+    // double-free
+    debug_check_double_dealloc([&] { return !chunk->contains(node, node_size_); }, info, mem);
+
+    auto index = offset / node_size_;
+    WPI_MEMORY_ASSERT(index < chunk->no_nodes);
+    chunk->deallocate(node, static_cast<unsigned char>(index));
+
+    ++capacity_;
+}
+
+std::size_t small_free_memory_list::alignment() const noexcept
+{
+    return alignment_for(node_size_);
+}
+
+chunk* small_free_memory_list::find_chunk_impl(std::size_t n) noexcept
+{
+    if (auto c = make_chunk(alloc_chunk_, n))
+        return c;
+    else if ((c = make_chunk(dealloc_chunk_, n)) != nullptr)
+        return c;
+
+    auto cur_forward  = alloc_chunk_->next;
+    auto cur_backward = alloc_chunk_->prev;
+
+    do
+    {
+        if (auto c = make_chunk(cur_forward, n))
+            return c;
+        else if ((c = make_chunk(cur_backward, n)) != nullptr)
+            return c;
+
+        cur_forward  = cur_forward->next;
+        cur_backward = cur_backward->prev;
+        WPI_MEMORY_ASSERT(cur_forward != alloc_chunk_);
+        WPI_MEMORY_ASSERT(cur_backward != alloc_chunk_);
+    } while (true);
+    WPI_MEMORY_UNREACHABLE("there is memory available somewhere...");
+    return nullptr;
+}
+
+chunk* small_free_memory_list::find_chunk_impl(unsigned char* node, chunk_base* first,
+                                               chunk_base* last) noexcept
+{
+    do
+    {
+        if (auto c = from_chunk(first, node, node_size_))
+            return c;
+        else if ((c = from_chunk(last, node, node_size_)) != nullptr)
+            return c;
+
+        first = first->next;
+        last  = last->prev;
+    } while (!greater(first, last));
+    return nullptr;
+}
+
+chunk* small_free_memory_list::find_chunk_impl(unsigned char* node) noexcept
+{
+    if (auto c = from_chunk(dealloc_chunk_, node, node_size_))
+        return c;
+    else if ((c = from_chunk(alloc_chunk_, node, node_size_)) != nullptr)
+        return c;
+    else if (less(dealloc_chunk_, node))
+    {
+        // node is in (dealloc_chunk_, base_.prev]
+        return find_chunk_impl(node, dealloc_chunk_->next, base_.prev);
+    }
+    else if (greater(dealloc_chunk_, node))
+    {
+        // node is in [base.next, dealloc_chunk_)
+        return find_chunk_impl(node, base_.next, dealloc_chunk_->prev);
+    }
+    WPI_MEMORY_UNREACHABLE("must be in one half");
+    return nullptr;
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/error.cpp b/wpiutil/src/main/native/thirdparty/memory/src/error.cpp
new file mode 100644
index 0000000..6261819
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/error.cpp
@@ -0,0 +1,106 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/error.hpp"
+
+#include <atomic>
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <cstdio>
+#endif
+
+using namespace wpi::memory;
+
+namespace
+{
+    void default_out_of_memory_handler(const allocator_info& info, std::size_t amount) noexcept
+    {
+#if WPI_HOSTED_IMPLEMENTATION
+        std::fprintf(stderr,
+                     "[%s] Allocator %s (at %p) ran out of memory trying to allocate %zu bytes.\n",
+                     WPI_MEMORY_LOG_PREFIX, info.name, info.allocator, amount);
+#endif
+    }
+
+    std::atomic<out_of_memory::handler> out_of_memory_h(default_out_of_memory_handler);
+} // namespace
+
+out_of_memory::handler out_of_memory::set_handler(out_of_memory::handler h)
+{
+    return out_of_memory_h.exchange(h ? h : default_out_of_memory_handler);
+}
+
+out_of_memory::handler out_of_memory::get_handler()
+{
+    return out_of_memory_h;
+}
+
+out_of_memory::out_of_memory(const allocator_info& info, std::size_t amount)
+: info_(info), amount_(amount)
+{
+    out_of_memory_h.load()(info, amount);
+}
+
+const char* out_of_memory::what() const noexcept
+{
+    return "low-level allocator is out of memory";
+}
+
+const char* out_of_fixed_memory::what() const noexcept
+{
+    return "fixed size allocator is out of memory";
+}
+
+namespace
+{
+    void default_bad_alloc_size_handler(const allocator_info& info, std::size_t passed,
+                                        std::size_t supported) noexcept
+    {
+#if WPI_HOSTED_IMPLEMENTATION
+        std::fprintf(stderr,
+                     "[%s] Allocator %s (at %p) received invalid size/alignment %zu, "
+                     "max supported is %zu\n",
+                     WPI_MEMORY_LOG_PREFIX, info.name, info.allocator, passed, supported);
+#endif
+    }
+
+    std::atomic<bad_allocation_size::handler> bad_alloc_size_h(default_bad_alloc_size_handler);
+} // namespace
+
+bad_allocation_size::handler bad_allocation_size::set_handler(bad_allocation_size::handler h)
+{
+    return bad_alloc_size_h.exchange(h ? h : default_bad_alloc_size_handler);
+}
+
+bad_allocation_size::handler bad_allocation_size::get_handler()
+{
+    return bad_alloc_size_h;
+}
+
+bad_allocation_size::bad_allocation_size(const allocator_info& info, std::size_t passed,
+                                         std::size_t supported)
+: info_(info), passed_(passed), supported_(supported)
+{
+    bad_alloc_size_h.load()(info_, passed_, supported_);
+}
+
+const char* bad_allocation_size::what() const noexcept
+{
+    return "allocation node size exceeds supported maximum of allocator";
+}
+
+const char* bad_node_size::what() const noexcept
+{
+    return "allocation node size exceeds supported maximum of allocator";
+}
+
+const char* bad_array_size::what() const noexcept
+{
+    return "allocation array size exceeds supported maximum of allocator";
+}
+
+const char* bad_alignment::what() const noexcept
+{
+    return "allocation alignment exceeds supported maximum of allocator";
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/heap_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/heap_allocator.cpp
new file mode 100644
index 0000000..0f559bd
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/heap_allocator.cpp
@@ -0,0 +1,85 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/heap_allocator.hpp"
+
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+
+#ifdef _WIN32
+#include <malloc.h>
+#include <windows.h>
+
+namespace
+{
+    HANDLE get_process_heap() noexcept
+    {
+        static auto heap = GetProcessHeap();
+        return heap;
+    }
+
+    std::size_t max_size() noexcept
+    {
+        return _HEAP_MAXREQ;
+    }
+} // namespace
+
+void* wpi::memory::heap_alloc(std::size_t size) noexcept
+{
+    return HeapAlloc(get_process_heap(), 0, size);
+}
+
+void wpi::memory::heap_dealloc(void* ptr, std::size_t) noexcept
+{
+    HeapFree(get_process_heap(), 0, ptr);
+}
+
+#elif WPI_HOSTED_IMPLEMENTATION
+#include <cstdlib>
+#include <memory>
+
+void* wpi::memory::heap_alloc(std::size_t size) noexcept
+{
+    return std::malloc(size);
+}
+
+void wpi::memory::heap_dealloc(void* ptr, std::size_t) noexcept
+{
+    std::free(ptr);
+}
+
+namespace
+{
+    std::size_t max_size() noexcept
+    {
+        return std::allocator_traits<std::allocator<char>>::max_size({});
+    }
+} // namespace
+#else
+// no implementation for heap_alloc/heap_dealloc
+
+namespace
+{
+    std::size_t max_size() noexcept
+    {
+        return std::size_t(-1);
+    }
+} // namespace
+#endif
+
+allocator_info detail::heap_allocator_impl::info() noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::heap_allocator", nullptr};
+}
+
+std::size_t detail::heap_allocator_impl::max_node_size() noexcept
+{
+    return max_size();
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class detail::lowlevel_allocator<detail::heap_allocator_impl>;
+template class wpi::memory::allocator_traits<heap_allocator>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/iteration_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/iteration_allocator.cpp
new file mode 100644
index 0000000..c174c13
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/iteration_allocator.cpp
@@ -0,0 +1,13 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/iteration_allocator.hpp"
+
+using namespace wpi::memory;
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::iteration_allocator<2>;
+template class wpi::memory::allocator_traits<iteration_allocator<2>>;
+template class wpi::memory::composable_allocator_traits<iteration_allocator<2>>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/malloc_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/malloc_allocator.cpp
new file mode 100644
index 0000000..f54817a
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/malloc_allocator.cpp
@@ -0,0 +1,24 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/config.hpp"
+#if WPI_HOSTED_IMPLEMENTATION
+
+#include "wpi/memory/malloc_allocator.hpp"
+
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+
+allocator_info detail::malloc_allocator_impl::info() noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::malloc_allocator", nullptr};
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class detail::lowlevel_allocator<detail::malloc_allocator_impl>;
+template class wpi::memory::allocator_traits<malloc_allocator>;
+#endif
+
+#endif // WPI_HOSTED_IMPLEMENTATION
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/memory_arena.cpp b/wpiutil/src/main/native/thirdparty/memory/src/memory_arena.cpp
new file mode 100644
index 0000000..d8454be
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/memory_arena.cpp
@@ -0,0 +1,73 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/memory_arena.hpp"
+
+#include <new>
+
+#include "wpi/memory/detail/align.hpp"
+
+using namespace wpi::memory;
+using namespace detail;
+
+void memory_block_stack::push(allocated_mb block) noexcept
+{
+    WPI_MEMORY_ASSERT(block.size >= sizeof(node));
+    WPI_MEMORY_ASSERT(is_aligned(block.memory, max_alignment));
+    auto next = ::new (block.memory) node(head_, block.size - implementation_offset());
+    head_     = next;
+}
+
+memory_block_stack::allocated_mb memory_block_stack::pop() noexcept
+{
+    WPI_MEMORY_ASSERT(head_);
+    auto to_pop = head_;
+    head_       = head_->prev;
+    return {to_pop, to_pop->usable_size + implementation_offset()};
+}
+
+void memory_block_stack::steal_top(memory_block_stack& other) noexcept
+{
+    WPI_MEMORY_ASSERT(other.head_);
+    auto to_steal = other.head_;
+    other.head_   = other.head_->prev;
+
+    to_steal->prev = head_;
+    head_          = to_steal;
+}
+
+bool memory_block_stack::owns(const void* ptr) const noexcept
+{
+    auto address = static_cast<const char*>(ptr);
+    for (auto cur = head_; cur; cur = cur->prev)
+    {
+        auto mem = static_cast<char*>(static_cast<void*>(cur));
+        if (address >= mem && address < mem + cur->usable_size)
+            return true;
+    }
+    return false;
+}
+
+std::size_t memory_block_stack::size() const noexcept
+{
+    std::size_t res = 0u;
+    for (auto cur = head_; cur; cur = cur->prev)
+        ++res;
+    return res;
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::memory_arena<static_block_allocator, true>;
+template class wpi::memory::memory_arena<static_block_allocator, false>;
+template class wpi::memory::memory_arena<virtual_block_allocator, true>;
+template class wpi::memory::memory_arena<virtual_block_allocator, false>;
+
+template class wpi::memory::growing_block_allocator<>;
+template class wpi::memory::memory_arena<growing_block_allocator<>, true>;
+template class wpi::memory::memory_arena<growing_block_allocator<>, false>;
+
+template class wpi::memory::fixed_block_allocator<>;
+template class wpi::memory::memory_arena<fixed_block_allocator<>, true>;
+template class wpi::memory::memory_arena<fixed_block_allocator<>, false>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/memory_pool.cpp b/wpiutil/src/main/native/thirdparty/memory/src/memory_pool.cpp
new file mode 100644
index 0000000..5a5e5ab
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/memory_pool.cpp
@@ -0,0 +1,28 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/memory_pool.hpp"
+
+#include "wpi/memory/debugging.hpp"
+
+using namespace wpi::memory;
+
+void detail::memory_pool_leak_handler::operator()(std::ptrdiff_t amount)
+{
+    get_leak_handler()({WPI_MEMORY_LOG_PREFIX "::memory_pool", this}, amount);
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::memory_pool<node_pool>;
+template class wpi::memory::memory_pool<array_pool>;
+template class wpi::memory::memory_pool<small_node_pool>;
+
+template class wpi::memory::allocator_traits<memory_pool<node_pool>>;
+template class wpi::memory::allocator_traits<memory_pool<array_pool>>;
+template class wpi::memory::allocator_traits<memory_pool<small_node_pool>>;
+
+template class wpi::memory::composable_allocator_traits<memory_pool<node_pool>>;
+template class wpi::memory::composable_allocator_traits<memory_pool<array_pool>>;
+template class wpi::memory::composable_allocator_traits<memory_pool<small_node_pool>>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/memory_pool_collection.cpp b/wpiutil/src/main/native/thirdparty/memory/src/memory_pool_collection.cpp
new file mode 100644
index 0000000..6366811
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/memory_pool_collection.cpp
@@ -0,0 +1,51 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/memory_pool_collection.hpp"
+
+#include "wpi/memory/debugging.hpp"
+
+using namespace wpi::memory;
+
+void detail::memory_pool_collection_leak_handler::operator()(std::ptrdiff_t amount)
+{
+    get_leak_handler()({WPI_MEMORY_LOG_PREFIX "::memory_pool_collection", this}, amount);
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::memory_pool_collection<node_pool, identity_buckets>;
+template class wpi::memory::memory_pool_collection<array_pool, identity_buckets>;
+template class wpi::memory::memory_pool_collection<small_node_pool, identity_buckets>;
+
+template class wpi::memory::memory_pool_collection<node_pool, log2_buckets>;
+template class wpi::memory::memory_pool_collection<array_pool, log2_buckets>;
+template class wpi::memory::memory_pool_collection<small_node_pool, log2_buckets>;
+
+template class wpi::memory::allocator_traits<
+    memory_pool_collection<node_pool, identity_buckets>>;
+template class wpi::memory::allocator_traits<
+    memory_pool_collection<array_pool, identity_buckets>>;
+template class wpi::memory::allocator_traits<
+    memory_pool_collection<small_node_pool, identity_buckets>>;
+
+template class wpi::memory::allocator_traits<memory_pool_collection<node_pool, log2_buckets>>;
+template class wpi::memory::allocator_traits<
+    memory_pool_collection<array_pool, log2_buckets>>;
+template class wpi::memory::allocator_traits<
+    memory_pool_collection<small_node_pool, log2_buckets>>;
+
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<node_pool, identity_buckets>>;
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<array_pool, identity_buckets>>;
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<small_node_pool, identity_buckets>>;
+
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<node_pool, log2_buckets>>;
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<array_pool, log2_buckets>>;
+template class wpi::memory::composable_allocator_traits<
+    memory_pool_collection<small_node_pool, log2_buckets>>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/memory_stack.cpp b/wpiutil/src/main/native/thirdparty/memory/src/memory_stack.cpp
new file mode 100644
index 0000000..8db5728
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/memory_stack.cpp
@@ -0,0 +1,21 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/memory_stack.hpp"
+
+#include "wpi/memory/debugging.hpp"
+
+using namespace wpi::memory;
+
+void detail::memory_stack_leak_handler::operator()(std::ptrdiff_t amount)
+{
+    get_leak_handler()({WPI_MEMORY_LOG_PREFIX "::memory_stack", this}, amount);
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::memory_stack<>;
+template class wpi::memory::memory_stack_raii_unwind<memory_stack<>>;
+template class wpi::memory::allocator_traits<memory_stack<>>;
+template class wpi::memory::composable_allocator_traits<memory_stack<>>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/new_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/new_allocator.cpp
new file mode 100644
index 0000000..2791182
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/new_allocator.cpp
@@ -0,0 +1,72 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/new_allocator.hpp"
+
+#if WPI_HOSTED_IMPLEMENTATION
+#include <memory>
+#endif
+
+#include <new>
+
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+
+allocator_info detail::new_allocator_impl::info() noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::new_allocator", nullptr};
+}
+
+void* detail::new_allocator_impl::allocate(std::size_t size, size_t) noexcept
+{
+    void* memory = nullptr;
+    while (true)
+    {
+        memory = ::operator new(size, std::nothrow);
+        if (memory)
+            break;
+
+        auto handler = std::get_new_handler();
+        if (handler)
+        {
+#if WPI_HAS_EXCEPTION_SUPPORT
+            try
+            {
+                handler();
+            }
+            catch (...)
+            {
+                return nullptr;
+            }
+#else
+            handler();
+#endif
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+    return memory;
+}
+
+void detail::new_allocator_impl::deallocate(void* ptr, std::size_t, size_t) noexcept
+{
+    ::operator delete(ptr);
+}
+
+std::size_t detail::new_allocator_impl::max_node_size() noexcept
+{
+#if WPI_HOSTED_IMPLEMENTATION
+    return std::allocator_traits<std::allocator<char>>::max_size({});
+#else
+    return std::size_t(-1);
+#endif
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class detail::lowlevel_allocator<detail::new_allocator_impl>;
+template class wpi::memory::allocator_traits<new_allocator>;
+#endif
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/static_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/static_allocator.cpp
new file mode 100644
index 0000000..15a88bf
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/static_allocator.cpp
@@ -0,0 +1,50 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/static_allocator.hpp"
+
+#include "wpi/memory/detail/debug_helpers.hpp"
+#include "wpi/memory/error.hpp"
+#include "wpi/memory/memory_arena.hpp"
+
+using namespace wpi::memory;
+
+void* static_allocator::allocate_node(std::size_t size, std::size_t alignment)
+{
+    auto mem = stack_.allocate(end_, size, alignment);
+    if (!mem)
+        WPI_THROW(out_of_fixed_memory(info(), size));
+    return mem;
+}
+
+allocator_info static_allocator::info() const noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::static_allocator", this};
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::allocator_traits<static_allocator>;
+#endif
+
+memory_block static_block_allocator::allocate_block()
+{
+    if (cur_ + block_size_ > end_)
+        WPI_THROW(out_of_fixed_memory(info(), block_size_));
+    auto mem = cur_;
+    cur_ += block_size_;
+    return {mem, block_size_};
+}
+
+void static_block_allocator::deallocate_block(memory_block block) noexcept
+{
+    detail::
+        debug_check_pointer([&] { return static_cast<char*>(block.memory) + block.size == cur_; },
+                            info(), block.memory);
+    cur_ -= block_size_;
+}
+
+allocator_info static_block_allocator::info() const noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::static_block_allocator", this};
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/temporary_allocator.cpp b/wpiutil/src/main/native/thirdparty/memory/src/temporary_allocator.cpp
new file mode 100644
index 0000000..fa85e99
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/temporary_allocator.cpp
@@ -0,0 +1,322 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/temporary_allocator.hpp"
+
+#include <new>
+#include <type_traits>
+
+#include "wpi/memory/detail/assert.hpp"
+#include "wpi/memory/default_allocator.hpp"
+#include "wpi/memory/error.hpp"
+
+using namespace wpi::memory;
+
+namespace
+{
+    void default_growth_tracker(std::size_t) noexcept {}
+
+    using temporary_impl_allocator        = default_allocator;
+    using temporary_impl_allocator_traits = allocator_traits<temporary_impl_allocator>;
+} // namespace
+
+detail::temporary_block_allocator::temporary_block_allocator(std::size_t block_size) noexcept
+: tracker_(default_growth_tracker), block_size_(block_size)
+{
+}
+
+detail::temporary_block_allocator::growth_tracker detail::temporary_block_allocator::
+    set_growth_tracker(growth_tracker t) noexcept
+{
+    auto old = tracker_;
+    tracker_ = t;
+    return old;
+}
+
+detail::temporary_block_allocator::growth_tracker detail::temporary_block_allocator::
+    get_growth_tracker() noexcept
+{
+    return tracker_;
+}
+
+memory_block detail::temporary_block_allocator::allocate_block()
+{
+    auto alloc  = temporary_impl_allocator();
+    auto memory = temporary_impl_allocator_traits::allocate_array(alloc, block_size_, 1,
+                                                                  detail::max_alignment);
+    auto block  = memory_block(memory, block_size_);
+    block_size_ = growing_block_allocator<temporary_impl_allocator>::grow_block_size(block_size_);
+    return block;
+}
+
+void detail::temporary_block_allocator::deallocate_block(memory_block block)
+{
+    auto alloc = temporary_impl_allocator();
+    temporary_impl_allocator_traits::deallocate_array(alloc, block.memory, block.size, 1,
+                                                      detail::max_alignment);
+}
+
+#if WPI_MEMORY_TEMPORARY_STACK_MODE >= 2
+// lifetime managment through the nifty counter and the list
+// note: I could have used a simple `thread_local` variable for the temporary stack
+// but this could lead to issues with destruction order
+// and more importantly I have to support platforms that can't handle non-trivial thread local's
+// hence I need to dynamically allocate the stack's and store them in a container
+// on program exit the container is iterated and all stack's are properly destroyed
+// if a thread exit can be detected, the dynamic memory of the stack is already released,
+// but not the stack itself destroyed
+
+#if !defined(__MINGW64__)
+
+// only use the thread exit detector if we have thread local and are not running on MinGW due to a bug
+// see: https://sourceforge.net/p/mingw-w64/bugs/527/
+#define WPI_MEMORY_THREAD_EXIT_DETECTOR 1
+
+#else
+#define WPI_MEMORY_THREAD_EXIT_DETECTOR 0
+
+#if defined(_MSC_VER)
+#pragma message(                                                                                   \
+    "thread_local doesn't support destructors, need to use the temporary_stack_initializer to ensure proper cleanup of the temporary memory")
+#else
+#warning                                                                                           \
+    "thread_local doesn't support destructors, need to use the temporary_stack_initializer to ensure proper cleanup of the temporary memory"
+#endif
+
+#endif
+
+static class detail::temporary_stack_list
+{
+public:
+    std::atomic<temporary_stack_list_node*> first;
+
+    temporary_stack* create_new(std::size_t size)
+    {
+        auto storage =
+            default_allocator().allocate_node(sizeof(temporary_stack), alignof(temporary_stack));
+        return ::new (storage) temporary_stack(0, size);
+    }
+
+    temporary_stack* find_unused()
+    {
+        for (auto ptr = first.load(); ptr; ptr = ptr->next_)
+        {
+            auto value = false;
+            if (ptr->in_use_.compare_exchange_strong(value, true))
+                return static_cast<temporary_stack*>(ptr);
+        }
+
+        return nullptr;
+    }
+
+    temporary_stack* create(std::size_t size)
+    {
+        if (auto ptr = find_unused())
+        {
+            WPI_MEMORY_ASSERT(ptr->in_use_);
+            ptr->stack_ = detail::temporary_stack_impl(size);
+            return ptr;
+        }
+        return create_new(size);
+    }
+
+    void clear(temporary_stack& stack)
+    {
+        // stack should be empty now, so shrink_to_fit() clears all memory
+        stack.stack_.shrink_to_fit();
+        stack.in_use_ = false; // mark as free
+    }
+
+    void destroy()
+    {
+        for (auto ptr = first.exchange(nullptr); ptr;)
+        {
+            auto stack = static_cast<temporary_stack*>(ptr);
+            auto next  = ptr->next_;
+
+            stack->~temporary_stack();
+            default_allocator().deallocate_node(stack, sizeof(temporary_stack),
+                                                alignof(temporary_stack));
+
+            ptr = next;
+        }
+
+        WPI_MEMORY_ASSERT_MSG(!first.load(),
+                                    "destroy() called while other threads are still running");
+    }
+} temporary_stack_list_obj;
+
+namespace
+{
+    thread_local std::size_t      nifty_counter;
+    thread_local temporary_stack* temp_stack = nullptr;
+
+#if WPI_MEMORY_THREAD_EXIT_DETECTOR
+    // don't use this on a bug
+    thread_local struct thread_exit_detector_t
+    {
+        ~thread_exit_detector_t() noexcept
+        {
+            if (temp_stack)
+                // clear automatically on thread exit, as the initializer's destructor does
+                // note: if another's thread_local variable destructor is called after this one
+                // and that destructor uses the temporary allocator
+                // the stack needs to grow again
+                // but who does temporary allocation in a destructor?!
+                temporary_stack_list_obj.clear(*temp_stack);
+        }
+    } thread_exit_detector;
+#endif
+} // namespace
+
+detail::temporary_stack_list_node::temporary_stack_list_node(int) noexcept : in_use_(true)
+{
+    next_ = temporary_stack_list_obj.first.load();
+    while (!temporary_stack_list_obj.first.compare_exchange_weak(next_, this))
+        ;
+#if WPI_MEMORY_THREAD_EXIT_DETECTOR
+    (void)&thread_exit_detector; // ODR-use it, so it will be created
+#endif
+}
+
+detail::temporary_allocator_dtor_t::temporary_allocator_dtor_t() noexcept
+{
+    ++nifty_counter;
+}
+
+detail::temporary_allocator_dtor_t::~temporary_allocator_dtor_t() noexcept
+{
+    if (--nifty_counter == 0u && temp_stack)
+        temporary_stack_list_obj.destroy();
+}
+
+temporary_stack_initializer::temporary_stack_initializer(std::size_t initial_size)
+{
+    if (!temp_stack)
+        temp_stack = temporary_stack_list_obj.create(initial_size);
+}
+
+temporary_stack_initializer::~temporary_stack_initializer() noexcept
+{
+    // don't destroy, nifty counter does that
+    // but can get rid of all the memory
+    if (temp_stack)
+        temporary_stack_list_obj.clear(*temp_stack);
+}
+
+temporary_stack& wpi::memory::get_temporary_stack(std::size_t initial_size)
+{
+    if (!temp_stack)
+        temp_stack = temporary_stack_list_obj.create(initial_size);
+    return *temp_stack;
+}
+
+#elif WPI_MEMORY_TEMPORARY_STACK_MODE == 1
+
+namespace
+{
+    WPI_THREAD_LOCAL alignas(
+        temporary_stack) char temporary_stack_storage[sizeof(temporary_stack)];
+    WPI_THREAD_LOCAL bool is_created = false;
+
+    temporary_stack& get() noexcept
+    {
+        WPI_MEMORY_ASSERT(is_created);
+        return *static_cast<temporary_stack*>(static_cast<void*>(&temporary_stack_storage));
+    }
+
+    void create(std::size_t initial_size)
+    {
+        if (!is_created)
+        {
+            ::new (static_cast<void*>(&temporary_stack_storage)) temporary_stack(initial_size);
+            is_created = true;
+        }
+    }
+} // namespace
+
+// explicit lifetime managment
+temporary_stack_initializer::temporary_stack_initializer(std::size_t initial_size)
+{
+    create(initial_size);
+}
+
+temporary_stack_initializer::~temporary_stack_initializer()
+{
+    if (is_created)
+        get().~temporary_stack();
+}
+
+temporary_stack& wpi::memory::get_temporary_stack(std::size_t initial_size)
+{
+    create(initial_size);
+    return get();
+}
+
+#else
+
+// no lifetime managment
+
+temporary_stack_initializer::temporary_stack_initializer(std::size_t initial_size)
+{
+    if (initial_size != 0u)
+        WPI_MEMORY_WARNING("temporary_stack_initializer() has no effect if "
+                                 "WPI_MEMORY_TEMPORARY_STACK == 0 (pass an initial size of 0 "
+                                 "to disable this message)");
+}
+
+temporary_stack_initializer::~temporary_stack_initializer() {}
+
+temporary_stack& wpi::memory::get_temporary_stack(std::size_t)
+{
+    WPI_MEMORY_UNREACHABLE("get_temporary_stack() called but stack is disabled by "
+                                 "WPI_MEMORY_TEMPORARY_STACK == 0");
+    std::abort();
+}
+
+#endif
+
+const temporary_stack_initializer::defer_create_t temporary_stack_initializer::defer_create;
+
+temporary_allocator::temporary_allocator() : temporary_allocator(get_temporary_stack()) {}
+
+temporary_allocator::temporary_allocator(temporary_stack& stack)
+: unwind_(stack), prev_(stack.top_), shrink_to_fit_(false)
+{
+    WPI_MEMORY_ASSERT(!prev_ || prev_->is_active());
+    stack.top_ = this;
+}
+
+temporary_allocator::~temporary_allocator() noexcept
+{
+    if (is_active())
+    {
+        auto& stack = unwind_.get_stack();
+        stack.top_  = prev_;
+        unwind_.unwind(); // manually call it now...
+        if (shrink_to_fit_)
+            // to call shrink_to_fit() afterwards
+            stack.stack_.shrink_to_fit();
+    }
+}
+
+void* temporary_allocator::allocate(std::size_t size, std::size_t alignment)
+{
+    WPI_MEMORY_ASSERT_MSG(is_active(), "object isn't the active allocator");
+    return unwind_.get_stack().stack_.allocate(size, alignment);
+}
+
+void temporary_allocator::shrink_to_fit() noexcept
+{
+    shrink_to_fit_ = true;
+}
+
+bool temporary_allocator::is_active() const noexcept
+{
+    WPI_MEMORY_ASSERT(unwind_.will_unwind());
+    auto res = unwind_.get_stack().top_ == this;
+    // check that prev is actually before this
+    WPI_MEMORY_ASSERT(!res || !prev_ || prev_->unwind_.get_marker() <= unwind_.get_marker());
+    return res;
+}
diff --git a/wpiutil/src/main/native/thirdparty/memory/src/virtual_memory.cpp b/wpiutil/src/main/native/thirdparty/memory/src/virtual_memory.cpp
new file mode 100644
index 0000000..fd7960f
--- /dev/null
+++ b/wpiutil/src/main/native/thirdparty/memory/src/virtual_memory.cpp
@@ -0,0 +1,240 @@
+// Copyright (C) 2015-2021 Müller <jonathanmueller.dev@gmail.com>
+// This file is subject to the license terms in the LICENSE file
+// found in the top-level directory of this distribution.
+
+#include "wpi/memory/virtual_memory.hpp"
+
+#include "wpi/memory/detail/debug_helpers.hpp"
+#include "wpi/memory/error.hpp"
+#include "wpi/memory/memory_arena.hpp"
+
+using namespace wpi::memory;
+
+void detail::virtual_memory_allocator_leak_handler::operator()(std::ptrdiff_t amount)
+{
+    detail::debug_handle_memory_leak({WPI_MEMORY_LOG_PREFIX "::virtual_memory_allocator",
+                                      nullptr},
+                                     amount);
+}
+
+#if defined(_WIN32)
+#include <windows.h>
+
+namespace
+{
+    std::size_t get_page_size() noexcept
+    {
+        static_assert(sizeof(std::size_t) >= sizeof(DWORD), "possible loss of data");
+
+        SYSTEM_INFO info;
+        GetSystemInfo(&info);
+        return std::size_t(info.dwPageSize);
+    }
+} // namespace
+
+const std::size_t wpi::memory::virtual_memory_page_size = get_page_size();
+
+void* wpi::memory::virtual_memory_reserve(std::size_t no_pages) noexcept
+{
+    auto pages =
+#if (_MSC_VER <= 1900) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+        VirtualAlloc(nullptr, no_pages * virtual_memory_page_size, MEM_RESERVE, PAGE_READWRITE);
+#else
+        VirtualAllocFromApp(nullptr, no_pages * virtual_memory_page_size, MEM_RESERVE,
+                            PAGE_READWRITE);
+#endif
+    return pages;
+}
+
+void wpi::memory::virtual_memory_release(void* pages, std::size_t) noexcept
+{
+    auto result = VirtualFree(pages, 0u, MEM_RELEASE);
+    WPI_MEMORY_ASSERT_MSG(result, "cannot release pages");
+}
+
+void* wpi::memory::virtual_memory_commit(void* memory, std::size_t no_pages) noexcept
+{
+    auto region =
+#if (_MSC_VER <= 1900) || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+        VirtualAlloc(memory, no_pages * virtual_memory_page_size, MEM_COMMIT, PAGE_READWRITE);
+#else
+        VirtualAllocFromApp(memory, no_pages * virtual_memory_page_size, MEM_COMMIT,
+                            PAGE_READWRITE);
+#endif
+    if (!region)
+        return nullptr;
+    WPI_MEMORY_ASSERT(region == memory);
+    return region;
+}
+
+void wpi::memory::virtual_memory_decommit(void* memory, std::size_t no_pages) noexcept
+{
+    auto result = VirtualFree(memory, no_pages * virtual_memory_page_size, MEM_DECOMMIT);
+    WPI_MEMORY_ASSERT_MSG(result, "cannot decommit memory");
+}
+#elif defined(__unix__) || defined(__APPLE__) || defined(__VXWORKS__)                              \
+    || defined(__QNXNTO__) // POSIX systems
+#include <sys/mman.h>
+#include <unistd.h>
+
+#if defined(PAGESIZE)
+const std::size_t wpi::memory::virtual_memory_page_size = PAGESIZE;
+#elif defined(PAGE_SIZE)
+const std::size_t wpi::memory::virtual_memory_page_size = PAGE_SIZE;
+#else
+const std::size_t wpi::memory::virtual_memory_page_size =
+    static_cast<std::size_t>(sysconf(_SC_PAGESIZE));
+#endif
+
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+void* wpi::memory::virtual_memory_reserve(std::size_t no_pages) noexcept
+{
+    auto pages = mmap(nullptr, no_pages * virtual_memory_page_size, PROT_NONE,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    return pages == MAP_FAILED ? nullptr : pages;
+}
+
+void wpi::memory::virtual_memory_release(void* pages, std::size_t no_pages) noexcept
+{
+    auto result = munmap(pages, no_pages * virtual_memory_page_size);
+    WPI_MEMORY_ASSERT_MSG(result == 0, "cannot release pages");
+    (void)result;
+}
+
+void* wpi::memory::virtual_memory_commit(void* memory, std::size_t no_pages) noexcept
+{
+    auto size   = no_pages * virtual_memory_page_size;
+    auto result = mprotect(memory, size, PROT_WRITE | PROT_READ);
+    if (result != 0)
+        return nullptr;
+
+// advise that the memory will be needed
+#if defined(MADV_WILLNEED)
+    madvise(memory, size, MADV_WILLNEED);
+#elif defined(POSIX_MADV_WILLNEED)
+    posix_madvise(memory, size, POSIX_MADV_WILLNEED);
+#endif
+
+    return memory;
+}
+
+void wpi::memory::virtual_memory_decommit(void* memory, std::size_t no_pages) noexcept
+{
+    auto size = no_pages * virtual_memory_page_size;
+// advise that the memory won't be needed anymore
+#if defined(MADV_FREE)
+    madvise(memory, size, MADV_FREE);
+#elif defined(MADV_DONTNEED)
+    madvise(memory, size, MADV_DONTNEED);
+#elif defined(POSIX_MADV_DONTNEED)
+    posix_madvise(memory, size, POSIX_MADV_DONTNEED);
+#endif
+
+    auto result = mprotect(memory, size, PROT_NONE);
+    WPI_MEMORY_ASSERT_MSG(result == 0, "cannot decommit memory");
+    (void)result;
+}
+#else
+#warning "virtual memory functions not available on your platform, define your own"
+#endif
+
+std::size_t wpi::memory::get_virtual_memory_page_size() noexcept
+{
+    return virtual_memory_page_size;
+}
+
+namespace
+{
+    std::size_t calc_no_pages(std::size_t size) noexcept
+    {
+        auto div  = size / virtual_memory_page_size;
+        auto rest = size % virtual_memory_page_size;
+
+        return div + (rest != 0u) + (detail::debug_fence_size ? 2u : 1u);
+    }
+} // namespace
+
+void* virtual_memory_allocator::allocate_node(std::size_t size, std::size_t)
+{
+    auto no_pages = calc_no_pages(size);
+    auto pages    = virtual_memory_reserve(no_pages);
+    if (!pages || !virtual_memory_commit(pages, no_pages))
+        WPI_THROW(
+            out_of_memory({WPI_MEMORY_LOG_PREFIX "::virtual_memory_allocator", nullptr},
+                          no_pages * virtual_memory_page_size));
+    on_allocate(size);
+
+    return detail::debug_fill_new(pages, size, virtual_memory_page_size);
+}
+
+void virtual_memory_allocator::deallocate_node(void* node, std::size_t size, std::size_t) noexcept
+{
+    auto pages = detail::debug_fill_free(node, size, virtual_memory_page_size);
+
+    on_deallocate(size);
+
+    auto no_pages = calc_no_pages(size);
+    virtual_memory_decommit(pages, no_pages);
+    virtual_memory_release(pages, no_pages);
+}
+
+std::size_t virtual_memory_allocator::max_node_size() const noexcept
+{
+    return std::size_t(-1);
+}
+
+std::size_t virtual_memory_allocator::max_alignment() const noexcept
+{
+    return virtual_memory_page_size;
+}
+
+#if WPI_MEMORY_EXTERN_TEMPLATE
+template class wpi::memory::allocator_traits<virtual_memory_allocator>;
+#endif
+
+virtual_block_allocator::virtual_block_allocator(std::size_t block_size, std::size_t no_blocks)
+: block_size_(block_size)
+{
+    WPI_MEMORY_ASSERT(block_size % virtual_memory_page_size == 0u);
+    WPI_MEMORY_ASSERT(no_blocks > 0);
+    auto total_size = block_size_ * no_blocks;
+    auto no_pages   = total_size / virtual_memory_page_size;
+
+    cur_ = static_cast<char*>(virtual_memory_reserve(no_pages));
+    if (!cur_)
+        WPI_THROW(out_of_memory(info(), total_size));
+    end_ = cur_ + total_size;
+}
+
+virtual_block_allocator::~virtual_block_allocator() noexcept
+{
+    virtual_memory_release(cur_, static_cast<std::size_t>(end_ - cur_) / virtual_memory_page_size);
+}
+
+memory_block virtual_block_allocator::allocate_block()
+{
+    if (std::size_t(end_ - cur_) < block_size_)
+        WPI_THROW(out_of_fixed_memory(info(), block_size_));
+    auto mem = virtual_memory_commit(cur_, block_size_ / virtual_memory_page_size);
+    if (!mem)
+        WPI_THROW(out_of_fixed_memory(info(), block_size_));
+    cur_ += block_size_;
+    return {mem, block_size_};
+}
+
+void virtual_block_allocator::deallocate_block(memory_block block) noexcept
+{
+    detail::debug_check_pointer([&]
+                                { return static_cast<char*>(block.memory) == cur_ - block_size_; },
+                                info(), block.memory);
+    cur_ -= block_size_;
+    virtual_memory_decommit(cur_, block_size_);
+}
+
+allocator_info virtual_block_allocator::info() noexcept
+{
+    return {WPI_MEMORY_LOG_PREFIX "::virtual_block_allocator", this};
+}
diff --git a/wpiutil/src/main/native/include/wpi/mpack.h b/wpiutil/src/main/native/thirdparty/mpack/include/wpi/mpack.h
similarity index 100%
rename from wpiutil/src/main/native/include/wpi/mpack.h
rename to wpiutil/src/main/native/thirdparty/mpack/include/wpi/mpack.h
diff --git a/wpiutil/src/main/native/cpp/mpack.cpp b/wpiutil/src/main/native/thirdparty/mpack/src/mpack.cpp
similarity index 99%
rename from wpiutil/src/main/native/cpp/mpack.cpp
rename to wpiutil/src/main/native/thirdparty/mpack/src/mpack.cpp
index fbcb6a4..af5fbd0 100644
--- a/wpiutil/src/main/native/cpp/mpack.cpp
+++ b/wpiutil/src/main/native/thirdparty/mpack/src/mpack.cpp
@@ -237,6 +237,7 @@
 }
 #endif
 
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
 
 /* mpack/mpack-common.c.c */
@@ -246,6 +247,7 @@
 /* #include "mpack-common.h" */
 
 MPACK_SILENCE_WARNINGS_BEGIN
+namespace mpack {
 
 const char* mpack_error_to_string(mpack_error_t error) {
     #if MPACK_STRINGS
@@ -970,6 +972,7 @@
 }
 #endif
 
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
 
 /* mpack/mpack-writer.c.c */
@@ -979,6 +982,7 @@
 /* #include "mpack-writer.h" */
 
 MPACK_SILENCE_WARNINGS_BEGIN
+namespace mpack {
 
 #if MPACK_WRITER
 
@@ -2727,6 +2731,7 @@
 #endif // MPACK_BUILDER
 #endif // MPACK_WRITER
 
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
 
 /* mpack/mpack-reader.c.c */
@@ -2736,6 +2741,7 @@
 /* #include "mpack-reader.h" */
 
 MPACK_SILENCE_WARNINGS_BEGIN
+namespace mpack {
 
 #if MPACK_READER
 
@@ -3996,6 +4002,7 @@
 
 #endif
 
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
 
 /* mpack/mpack-expect.c.c */
@@ -4005,6 +4012,7 @@
 /* #include "mpack-expect.h" */
 
 MPACK_SILENCE_WARNINGS_BEGIN
+namespace mpack {
 
 #if MPACK_EXPECT
 
@@ -4861,6 +4869,7 @@
 
 #endif
 
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
 
 /* mpack/mpack-node.c.c */
@@ -4870,6 +4879,7 @@
 /* #include "mpack-node.h" */
 
 MPACK_SILENCE_WARNINGS_BEGIN
+namespace mpack {
 
 #if MPACK_NODE
 
@@ -7247,5 +7257,5 @@
 
 #endif
 
-}  // namespace wpi
+}  // namespace mpack
 MPACK_SILENCE_WARNINGS_END
diff --git a/wpiutil/src/main/native/include/wpi/Signal.h b/wpiutil/src/main/native/thirdparty/sigslot/include/wpi/Signal.h
similarity index 100%
rename from wpiutil/src/main/native/include/wpi/Signal.h
rename to wpiutil/src/main/native/thirdparty/sigslot/include/wpi/Signal.h
diff --git a/wpiutil/src/main/native/windows/Demangle.cpp b/wpiutil/src/main/native/windows/Demangle.cpp
index 1b0a8a7..18be371 100644
--- a/wpiutil/src/main/native/windows/Demangle.cpp
+++ b/wpiutil/src/main/native/windows/Demangle.cpp
@@ -22,8 +22,9 @@
   char buffer[256];
   DWORD sz = UnDecorateSymbolName(buf.c_str(), buffer, sizeof(buffer),
                                   UNDNAME_COMPLETE);
-  if (sz == 0)
+  if (sz == 0) {
     return std::string{mangledSymbol};
+  }
   return std::string(buffer, sz);
 }
 
diff --git a/wpiutil/src/main/native/windows/DynamicDns.cpp b/wpiutil/src/main/native/windows/DynamicDns.cpp
deleted file mode 100644
index c59d554..0000000
--- a/wpiutil/src/main/native/windows/DynamicDns.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "DynamicDns.h"
-
-using namespace wpi;
-
-DynamicDns& DynamicDns::GetDynamicDns() {
-  static DynamicDns dns;
-  return dns;
-}
-
-DynamicDns::DynamicDns() {
-  HMODULE library = LoadLibraryW(L"dnsapi");
-
-  if (library == nullptr) {
-    return;
-  }
-
-  DnsServiceFreeInstancePtr = (DnsServiceFreeInstanceFunc)GetProcAddress(
-      library, "DnsServiceFreeInstance");
-  DnsServiceConstructInstancePtr =
-      (DnsServiceConstructInstanceFunc)GetProcAddress(
-          library, "DnsServiceConstructInstance");
-  DnsServiceRegisterPtr =
-      (DnsServiceRegisterFunc)GetProcAddress(library, "DnsServiceRegister");
-  DnsServiceDeRegisterPtr =
-      (DnsServiceDeRegisterFunc)GetProcAddress(library, "DnsServiceDeRegister");
-
-  CanDnsAnnounce = DnsServiceFreeInstancePtr &&
-                   DnsServiceConstructInstancePtr && DnsServiceRegisterPtr &&
-                   DnsServiceDeRegisterPtr;
-
-  DnsServiceBrowsePtr =
-      (DnsServiceBrowseFunc)GetProcAddress(library, "DnsServiceBrowse");
-  DnsServiceBrowseCancelPtr = (DnsServiceBrowseCancelFunc)GetProcAddress(
-      library, "DnsServiceBrowseCancel");
-
-  CanDnsResolve = DnsServiceBrowsePtr && DnsServiceBrowseCancelPtr;
-}
diff --git a/wpiutil/src/main/native/windows/DynamicDns.h b/wpiutil/src/main/native/windows/DynamicDns.h
deleted file mode 100644
index c8bee04..0000000
--- a/wpiutil/src/main/native/windows/DynamicDns.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#include <windows.h>
-
-#include <WinDNS.h>
-
-namespace wpi {
-class DynamicDns {
- public:
-  using DnsServiceFreeInstanceFunc =
-      VOID(WINAPI*)(_In_ PDNS_SERVICE_INSTANCE pInstance);
-
-  using DnsServiceConstructInstanceFunc = PDNS_SERVICE_INSTANCE(WINAPI*)(
-      _In_ PCWSTR pServiceName, _In_ PCWSTR pHostName,
-      _In_opt_ PIP4_ADDRESS pIp4, _In_opt_ PIP6_ADDRESS pIp6, _In_ WORD wPort,
-      _In_ WORD wPriority, _In_ WORD wWeight, _In_ DWORD dwPropertiesCount,
-      _In_reads_(dwPropertiesCount) PCWSTR* keys,
-      _In_reads_(dwPropertiesCount) PCWSTR* values);
-
-  using DnsServiceRegisterFunc =
-      DWORD(WINAPI*)(_In_ PDNS_SERVICE_REGISTER_REQUEST pRequest,
-                     _Inout_opt_ PDNS_SERVICE_CANCEL pCancel);
-
-  using DnsServiceDeRegisterFunc =
-      DWORD(WINAPI*)(_In_ PDNS_SERVICE_REGISTER_REQUEST pRequest,
-                     _Inout_opt_ PDNS_SERVICE_CANCEL pCancel);
-
-  using DnsServiceBrowseFunc =
-      DNS_STATUS(WINAPI*)(_In_ PDNS_SERVICE_BROWSE_REQUEST pRequest,
-                          _Inout_ PDNS_SERVICE_CANCEL pCancel);
-
-  using DnsServiceBrowseCancelFunc =
-      DNS_STATUS(WINAPI*)(_In_ PDNS_SERVICE_CANCEL pCancelHandle);
-
-  DnsServiceBrowseFunc DnsServiceBrowsePtr{nullptr};
-  DnsServiceBrowseCancelFunc DnsServiceBrowseCancelPtr{nullptr};
-
-  DnsServiceFreeInstanceFunc DnsServiceFreeInstancePtr{nullptr};
-  DnsServiceConstructInstanceFunc DnsServiceConstructInstancePtr{nullptr};
-  DnsServiceRegisterFunc DnsServiceRegisterPtr{nullptr};
-  DnsServiceDeRegisterFunc DnsServiceDeRegisterPtr{nullptr};
-
-  bool CanDnsAnnounce{false};
-  bool CanDnsResolve{false};
-
-  static DynamicDns& GetDynamicDns();
-
- private:
-  DynamicDns();
-};
-}  // namespace wpi
diff --git a/wpiutil/src/main/native/windows/MulticastServiceAnnouncer.cpp b/wpiutil/src/main/native/windows/MulticastServiceAnnouncer.cpp
deleted file mode 100644
index 2327b8b..0000000
--- a/wpiutil/src/main/native/windows/MulticastServiceAnnouncer.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#include "wpi/MulticastServiceAnnouncer.h"
-
-#include <string>
-#include <vector>
-
-#include "DynamicDns.h"
-#include "wpi/ConvertUTF.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringExtras.h"
-#include "wpi/hostname.h"
-
-using namespace wpi;
-
-struct ImplBase {
-  wpi::DynamicDns& dynamicDns = wpi::DynamicDns::GetDynamicDns();
-  PDNS_SERVICE_INSTANCE serviceInstance = nullptr;
-  HANDLE event = nullptr;
-};
-
-struct MulticastServiceAnnouncer::Impl : ImplBase {
-  std::wstring serviceType;
-  std::wstring serviceInstanceName;
-  std::wstring hostName;
-  int port;
-  std::vector<std::wstring> keys;
-  std::vector<PCWSTR> keyPtrs;
-  std::vector<std::wstring> values;
-  std::vector<PCWSTR> valuePtrs;
-
-  template <typename T>
-  Impl(std::string_view serviceName, std::string_view serviceType, int port,
-       wpi::span<const std::pair<T, T>> txt);
-};
-
-template <typename T>
-MulticastServiceAnnouncer::Impl::Impl(std::string_view serviceName,
-                                      std::string_view serviceType, int port,
-                                      wpi::span<const std::pair<T, T>> txt) {
-  if (!dynamicDns.CanDnsAnnounce) {
-    return;
-  }
-
-  this->port = port;
-
-  wpi::SmallVector<wchar_t, 128> wideStorage;
-  std::string hostName = wpi::GetHostname() + ".local";
-
-  for (auto&& i : txt) {
-    wideStorage.clear();
-    wpi::sys::windows::UTF8ToUTF16(i.first, wideStorage);
-    this->keys.emplace_back(
-        std::wstring{wideStorage.data(), wideStorage.size()});
-    wideStorage.clear();
-    wpi::sys::windows::UTF8ToUTF16(i.second, wideStorage);
-    this->values.emplace_back(
-        std::wstring{wideStorage.data(), wideStorage.size()});
-  }
-
-  for (size_t i = 0; i < this->keys.size(); i++) {
-    this->keyPtrs.emplace_back(this->keys[i].c_str());
-    this->valuePtrs.emplace_back(this->values[i].c_str());
-  }
-
-  wpi::SmallString<128> storage;
-
-  wideStorage.clear();
-  wpi::sys::windows::UTF8ToUTF16(hostName, wideStorage);
-
-  this->hostName = std::wstring{wideStorage.data(), wideStorage.size()};
-
-  wideStorage.clear();
-  if (wpi::ends_with_lower(serviceType, ".local")) {
-    wpi::sys::windows::UTF8ToUTF16(serviceType, wideStorage);
-  } else {
-    storage.clear();
-    storage.append(serviceType);
-    storage.append(".local");
-    wpi::sys::windows::UTF8ToUTF16(storage.str(), wideStorage);
-  }
-  this->serviceType = std::wstring{wideStorage.data(), wideStorage.size()};
-
-  wideStorage.clear();
-  storage.clear();
-  storage.append(serviceName);
-  storage.append(".");
-  storage.append(serviceType);
-  if (!wpi::ends_with_lower(serviceType, ".local")) {
-    storage.append(".local");
-  }
-
-  wpi::sys::windows::UTF8ToUTF16(storage.str(), wideStorage);
-  this->serviceInstanceName =
-      std::wstring{wideStorage.data(), wideStorage.size()};
-}
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string, std::string>> txt) {
-  pImpl = std::make_unique<Impl>(serviceName, serviceType, port, txt);
-}
-
-MulticastServiceAnnouncer::MulticastServiceAnnouncer(
-    std::string_view serviceName, std::string_view serviceType, int port,
-    wpi::span<const std::pair<std::string_view, std::string_view>> txt) {
-  pImpl = std::make_unique<Impl>(serviceName, serviceType, port, txt);
-}
-
-MulticastServiceAnnouncer::~MulticastServiceAnnouncer() noexcept {
-  Stop();
-}
-
-bool MulticastServiceAnnouncer::HasImplementation() const {
-  return pImpl->dynamicDns.CanDnsAnnounce;
-}
-
-static void WINAPI DnsServiceRegisterCallback(DWORD /*Status*/,
-                                              PVOID pQueryContext,
-                                              PDNS_SERVICE_INSTANCE pInstance) {
-  ImplBase* impl = reinterpret_cast<ImplBase*>(pQueryContext);
-
-  impl->serviceInstance = pInstance;
-
-  SetEvent(impl->event);
-}
-
-void MulticastServiceAnnouncer::Start() {
-  if (pImpl->serviceInstance) {
-    return;
-  }
-
-  if (!pImpl->dynamicDns.CanDnsAnnounce) {
-    return;
-  }
-
-  PDNS_SERVICE_INSTANCE serviceInst =
-      pImpl->dynamicDns.DnsServiceConstructInstancePtr(
-          pImpl->serviceInstanceName.c_str(), pImpl->hostName.c_str(), nullptr,
-          nullptr, pImpl->port, 0, 0, static_cast<DWORD>(pImpl->keyPtrs.size()),
-          pImpl->keyPtrs.data(), pImpl->valuePtrs.data());
-  if (serviceInst == nullptr) {
-    return;
-  }
-
-  DNS_SERVICE_REGISTER_REQUEST registerRequest = {};
-  registerRequest.pQueryContext = static_cast<ImplBase*>(pImpl.get());
-  registerRequest.pRegisterCompletionCallback = DnsServiceRegisterCallback;
-  registerRequest.Version = DNS_QUERY_REQUEST_VERSION1;
-  registerRequest.unicastEnabled = false;
-  registerRequest.pServiceInstance = serviceInst;
-  registerRequest.InterfaceIndex = 0;
-
-  pImpl->event = CreateEvent(NULL, true, false, NULL);
-
-  if (pImpl->dynamicDns.DnsServiceRegisterPtr(&registerRequest, nullptr) ==
-      DNS_REQUEST_PENDING) {
-    WaitForSingleObject(pImpl->event, INFINITE);
-  }
-
-  pImpl->dynamicDns.DnsServiceFreeInstancePtr(serviceInst);
-  CloseHandle(pImpl->event);
-  pImpl->event = nullptr;
-}
-
-static void WINAPI DnsServiceDeRegisterCallback(
-    DWORD /*Status*/, PVOID pQueryContext, PDNS_SERVICE_INSTANCE pInstance) {
-  ImplBase* impl = reinterpret_cast<ImplBase*>(pQueryContext);
-
-  if (pInstance != nullptr) {
-    impl->dynamicDns.DnsServiceFreeInstancePtr(pInstance);
-    pInstance = nullptr;
-  }
-
-  SetEvent(impl->event);
-}
-
-void MulticastServiceAnnouncer::Stop() {
-  if (!pImpl->dynamicDns.CanDnsAnnounce) {
-    return;
-  }
-
-  if (pImpl->serviceInstance == nullptr) {
-    return;
-  }
-
-  pImpl->event = CreateEvent(NULL, true, false, NULL);
-  DNS_SERVICE_REGISTER_REQUEST registerRequest = {};
-  registerRequest.pQueryContext = static_cast<ImplBase*>(pImpl.get());
-  registerRequest.pRegisterCompletionCallback = DnsServiceDeRegisterCallback;
-  registerRequest.Version = DNS_QUERY_REQUEST_VERSION1;
-  registerRequest.unicastEnabled = false;
-  registerRequest.pServiceInstance = pImpl->serviceInstance;
-  registerRequest.InterfaceIndex = 0;
-
-  if (pImpl->dynamicDns.DnsServiceDeRegisterPtr(&registerRequest, nullptr) ==
-      DNS_REQUEST_PENDING) {
-    WaitForSingleObject(pImpl->event, INFINITE);
-  }
-
-  pImpl->dynamicDns.DnsServiceFreeInstancePtr(pImpl->serviceInstance);
-  pImpl->serviceInstance = nullptr;
-  CloseHandle(pImpl->event);
-  pImpl->event = nullptr;
-}
diff --git a/wpiutil/src/main/native/windows/MulticastServiceResolver.cpp b/wpiutil/src/main/native/windows/MulticastServiceResolver.cpp
deleted file mode 100644
index 115b43f..0000000
--- a/wpiutil/src/main/native/windows/MulticastServiceResolver.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#include "wpi/MulticastServiceResolver.h"
-
-#include <string>
-
-#include "DynamicDns.h"
-#include "wpi/ConvertUTF.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringExtras.h"
-
-#pragma comment(lib, "dnsapi")
-
-using namespace wpi;
-
-struct MulticastServiceResolver::Impl {
-  wpi::DynamicDns& dynamicDns = wpi::DynamicDns::GetDynamicDns();
-  std::wstring serviceType;
-  DNS_SERVICE_CANCEL serviceCancel{nullptr};
-
-  MulticastServiceResolver* resolver;
-
-  void onFound(ServiceData&& data) {
-    resolver->PushData(std::forward<ServiceData>(data));
-  }
-};
-
-MulticastServiceResolver::MulticastServiceResolver(
-    std::string_view serviceType) {
-  pImpl = std::make_unique<Impl>();
-  pImpl->resolver = this;
-
-  if (!pImpl->dynamicDns.CanDnsResolve) {
-    return;
-  }
-
-  wpi::SmallVector<wchar_t, 128> wideStorage;
-
-  if (wpi::ends_with_lower(serviceType, ".local")) {
-    wpi::sys::windows::UTF8ToUTF16(serviceType, wideStorage);
-  } else {
-    wpi::SmallString<128> storage;
-    storage.append(serviceType);
-    storage.append(".local");
-    wpi::sys::windows::UTF8ToUTF16(storage.str(), wideStorage);
-  }
-  pImpl->serviceType = std::wstring{wideStorage.data(), wideStorage.size()};
-}
-
-MulticastServiceResolver::~MulticastServiceResolver() noexcept {
-  Stop();
-}
-
-bool MulticastServiceResolver::HasImplementation() const {
-  return pImpl->dynamicDns.CanDnsResolve;
-}
-
-static _Function_class_(DNS_QUERY_COMPLETION_ROUTINE) VOID WINAPI
-    DnsCompletion(_In_ PVOID pQueryContext,
-                  _Inout_ PDNS_QUERY_RESULT pQueryResults) {
-  MulticastServiceResolver::Impl* impl =
-      reinterpret_cast<MulticastServiceResolver::Impl*>(pQueryContext);
-
-  wpi::SmallVector<DNS_RECORDW*, 4> PtrRecords;
-  wpi::SmallVector<DNS_RECORDW*, 4> SrvRecords;
-  wpi::SmallVector<DNS_RECORDW*, 4> TxtRecords;
-  wpi::SmallVector<DNS_RECORDW*, 4> ARecords;
-
-  {
-    DNS_RECORDW* current = pQueryResults->pQueryRecords;
-    while (current != nullptr) {
-      switch (current->wType) {
-        case DNS_TYPE_PTR:
-          PtrRecords.push_back(current);
-          break;
-        case DNS_TYPE_SRV:
-          SrvRecords.push_back(current);
-          break;
-        case DNS_TYPE_TEXT:
-          TxtRecords.push_back(current);
-          break;
-        case DNS_TYPE_A:
-          ARecords.push_back(current);
-          break;
-      }
-      current = current->pNext;
-    }
-  }
-
-  for (DNS_RECORDW* Ptr : PtrRecords) {
-    if (std::wstring_view{Ptr->pName} != impl->serviceType) {
-      continue;
-    }
-
-    std::wstring_view nameHost = Ptr->Data.Ptr.pNameHost;
-    DNS_RECORDW* foundSrv = nullptr;
-    for (DNS_RECORDW* Srv : SrvRecords) {
-      if (std::wstring_view{Srv->pName} == nameHost) {
-        foundSrv = Srv;
-        break;
-      }
-    }
-
-    if (!foundSrv) {
-      continue;
-    }
-
-    for (DNS_RECORDW* A : ARecords) {
-      if (std::wstring_view{A->pName} ==
-          std::wstring_view{foundSrv->Data.Srv.pNameTarget}) {
-        MulticastServiceResolver::ServiceData data;
-        wpi::SmallString<128> storage;
-        for (DNS_RECORDW* Txt : TxtRecords) {
-          if (std::wstring_view{Txt->pName} == nameHost) {
-            for (DWORD i = 0; i < Txt->Data.Txt.dwStringCount; i++) {
-              std::wstring_view wideView = Txt->Data.TXT.pStringArray[i];
-              size_t splitIndex = wideView.find(L'=');
-              if (splitIndex == wideView.npos) {
-                // Todo make this just do key
-                continue;
-              }
-              storage.clear();
-              wpi::span<const wpi::UTF16> wideStr{
-                  reinterpret_cast<const wpi::UTF16*>(wideView.data()),
-                  splitIndex};
-              wpi::convertUTF16ToUTF8String(wideStr, storage);
-              auto& pair = data.txt.emplace_back(
-                  std::pair<std::string, std::string>{storage.string(), {}});
-              storage.clear();
-              wideStr = wpi::span<const wpi::UTF16>{
-                  reinterpret_cast<const wpi::UTF16*>(wideView.data() +
-                                                      splitIndex + 1),
-                  wideView.size() - splitIndex - 1};
-              wpi::convertUTF16ToUTF8String(wideStr, storage);
-              pair.second = storage.string();
-            }
-          }
-        }
-
-        storage.clear();
-        wpi::span<const wpi::UTF16> wideHostName{
-            reinterpret_cast<const wpi::UTF16*>(A->pName), wcslen(A->pName)};
-        wpi::convertUTF16ToUTF8String(wideHostName, storage);
-        storage.append(".");
-
-        data.hostName = storage.string();
-        storage.clear();
-
-        int len = nameHost.find(impl->serviceType.c_str());
-        wpi::span<const wpi::UTF16> wideServiceName{
-            reinterpret_cast<const wpi::UTF16*>(nameHost.data()),
-            nameHost.size()};
-        if (len != nameHost.npos) {
-          wideServiceName = wideServiceName.subspan(0, len - 1);
-        }
-        wpi::convertUTF16ToUTF8String(wideServiceName, storage);
-
-        data.serviceName = storage.string();
-        data.port = foundSrv->Data.Srv.wPort;
-        data.ipv4Address = A->Data.A.IpAddress;
-
-        impl->onFound(std::move(data));
-      }
-    }
-  }
-  DnsFree(pQueryResults->pQueryRecords, DNS_FREE_TYPE::DnsFreeRecordList);
-}
-
-void MulticastServiceResolver::Start() {
-  if (pImpl->serviceCancel.reserved != nullptr) {
-    return;
-  }
-
-  if (!pImpl->dynamicDns.CanDnsResolve) {
-    return;
-  }
-
-  DNS_SERVICE_BROWSE_REQUEST request = {};
-  request.InterfaceIndex = 0;
-  request.pQueryContext = pImpl.get();
-  request.QueryName = pImpl->serviceType.c_str();
-  request.Version = 2;
-  request.pBrowseCallbackV2 = DnsCompletion;
-  pImpl->dynamicDns.DnsServiceBrowsePtr(&request, &pImpl->serviceCancel);
-}
-
-void MulticastServiceResolver::Stop() {
-  if (!pImpl->dynamicDns.CanDnsResolve) {
-    return;
-  }
-
-  if (pImpl->serviceCancel.reserved == nullptr) {
-    return;
-  }
-
-  pImpl->dynamicDns.DnsServiceBrowseCancelPtr(&pImpl->serviceCancel);
-  pImpl->serviceCancel.reserved = nullptr;
-}
diff --git a/wpiutil/src/main/native/windows/StackTrace.cpp b/wpiutil/src/main/native/windows/StackTrace.cpp
index bab5f83..de31b2a 100644
--- a/wpiutil/src/main/native/windows/StackTrace.cpp
+++ b/wpiutil/src/main/native/windows/StackTrace.cpp
@@ -8,6 +8,8 @@
 #include "wpi/ConvertUTF.h"
 #include "wpi/SmallString.h"
 
+#if defined(_MSC_VER)
+
 namespace {
 class StackTraceWalker : public StackWalker {
  public:
@@ -40,3 +42,5 @@
 }
 
 }  // namespace wpi
+
+#endif  // defined(_MSC_VER)
diff --git a/wpiutil/src/main/native/windows/StackWalker.cpp b/wpiutil/src/main/native/windows/StackWalker.cpp
index 237360a..6f0fbf2 100644
--- a/wpiutil/src/main/native/windows/StackWalker.cpp
+++ b/wpiutil/src/main/native/windows/StackWalker.cpp
@@ -1,4 +1,4 @@
-/**********************************************************************
+﻿/**********************************************************************
  *
  * StackWalker.cpp
  * https://github.com/JochenKalmbach/StackWalker
@@ -485,8 +485,8 @@
       if (hToolhelp == NULL)
         continue;
       createToolhelp32Snapshot = (tCT32S)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
-      module32First = (tM32F)GetProcAddress(hToolhelp, strModule32First);
-      module32Next = (tM32N)GetProcAddress(hToolhelp, strModule32Next);
+      module32First = (tM32F)GetProcAddress(hToolhelp, strModule32First);  
+      module32Next = (tM32N)GetProcAddress(hToolhelp, strModule32Next); 
       if ((createToolhelp32Snapshot != NULL) && (module32First != NULL) && (module32Next != NULL))
         break; // found the functions!
       FreeLibrary(hToolhelp);
diff --git a/wpiutil/src/main/native/windows/StackWalker.h b/wpiutil/src/main/native/windows/StackWalker.h
index 750de96..89be951 100644
--- a/wpiutil/src/main/native/windows/StackWalker.h
+++ b/wpiutil/src/main/native/windows/StackWalker.h
@@ -1,3 +1,8 @@
+#ifndef __STACKWALKER_H__
+#define __STACKWALKER_H__
+
+#if defined(_MSC_VER)
+
 /**********************************************************************
  *
  * StackWalker.h
@@ -32,6 +37,8 @@
  *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * **********************************************************************/
+// #pragma once is supported starting with _MSC_VER 1000,
+// so we need not to check the version (because we only support _MSC_VER >= 1100)!
 #pragma once
 
 #include <windows.h>
@@ -105,7 +112,11 @@
 
   BOOL ShowObject(LPVOID pObject);
 
+#if _MSC_VER >= 1300
+  // due to some reasons, the "STACKWALK_MAX_NAMELEN" must be declared as "public"
+  // in older compilers in order to use it... starting with VC7 we can declare it as "protected"
 protected:
+#endif
   enum
   {
     STACKWALK_MAX_NAMELEN = 1024
@@ -176,3 +187,7 @@
     c.ContextFlags = contextFlags;                                \
     RtlCaptureContext(&c);                                        \
   } while (0);
+
+#endif //defined(_MSC_VER)
+
+#endif // __STACKWALKER_H__
diff --git a/wpiutil/src/netconsoleServer/native/cpp/main.cpp b/wpiutil/src/netconsoleServer/native/cpp/main.cpp
deleted file mode 100644
index c43a670..0000000
--- a/wpiutil/src/netconsoleServer/native/cpp/main.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#ifdef __APPLE__
-#include <util.h>
-#elif !defined(_WIN32)
-#include <pty.h>
-#endif
-
-#include <cstdio>
-
-#include "fmt/format.h"
-#include "wpi/MathExtras.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringExtras.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/timestamp.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Pipe.h"
-#include "wpi/uv/Process.h"
-#include "wpi/uv/Signal.h"
-#include "wpi/uv/Tcp.h"
-#include "wpi/uv/Tty.h"
-#include "wpi/uv/Udp.h"
-#include "wpi/uv/util.h"
-
-namespace uv = wpi::uv;
-
-static uint64_t startTime = wpi::Now();
-
-static bool NewlineBuffer(std::string& rem, uv::Buffer& buf, size_t len,
-                          wpi::SmallVectorImpl<uv::Buffer>& bufs, bool tcp,
-                          uint16_t tcpSeq) {
-  // scan for last newline
-  std::string_view str(buf.base, len);
-  size_t idx = str.rfind('\n');
-  if (idx == std::string_view::npos) {
-    // no newline yet, just keep appending to remainder
-    rem += str;
-    return false;
-  }
-
-  // build output
-  wpi::raw_uv_ostream out(bufs, 4096);
-  std::string_view toCopy = wpi::slice(str, 0, idx + 1);
-  if (tcp) {
-    // Header is 2 byte len, 1 byte type, 4 byte timestamp, 2 byte sequence num
-    uint32_t ts = wpi::FloatToBits((wpi::Now() - startTime) * 1.0e-6);
-    uint16_t len = rem.size() + toCopy.size() + 1 + 4 + 2;
-    const uint8_t header[] = {static_cast<uint8_t>((len >> 8) & 0xff),
-                              static_cast<uint8_t>(len & 0xff),
-                              12,
-                              static_cast<uint8_t>((ts >> 24) & 0xff),
-                              static_cast<uint8_t>((ts >> 16) & 0xff),
-                              static_cast<uint8_t>((ts >> 8) & 0xff),
-                              static_cast<uint8_t>(ts & 0xff),
-                              static_cast<uint8_t>((tcpSeq >> 8) & 0xff),
-                              static_cast<uint8_t>(tcpSeq & 0xff)};
-    out << wpi::span<const uint8_t>(header);
-  }
-  out << rem << toCopy;
-
-  // reset remainder
-  rem = wpi::slice(str, idx + 1, std::string_view::npos);
-  return true;
-}
-
-static void CopyUdp(uv::Stream& in, std::shared_ptr<uv::Udp> out,
-                    bool broadcast) {
-  sockaddr_in addr;
-  if (broadcast) {
-    out->SetBroadcast(true);
-    uv::NameToAddr("0.0.0.0", 6666, &addr);
-  } else {
-    uv::NameToAddr("127.0.0.1", 6666, &addr);
-  }
-
-  in.data.connect(
-      [rem = std::make_shared<std::string>(), outPtr = out.get(), addr](
-          uv::Buffer& buf, size_t len) {
-        // build buffers
-        wpi::SmallVector<uv::Buffer, 4> bufs;
-        if (!NewlineBuffer(*rem, buf, len, bufs, false, 0)) {
-          return;
-        }
-
-        // send output
-        outPtr->Send(addr, bufs, [](auto bufs2, uv::Error) {
-          for (auto buf : bufs2) {
-            buf.Deallocate();
-          }
-        });
-      },
-      out);
-}
-
-static void CopyTcp(uv::Stream& in, std::shared_ptr<uv::Stream> out) {
-  struct StreamData {
-    std::string rem;
-    uint16_t seq = 0;
-  };
-  in.data.connect(
-      [data = std::make_shared<StreamData>(), outPtr = out.get()](
-          uv::Buffer& buf, size_t len) {
-        // build buffers
-        wpi::SmallVector<uv::Buffer, 4> bufs;
-        if (!NewlineBuffer(data->rem, buf, len, bufs, true, data->seq++)) {
-          return;
-        }
-
-        // send output
-        outPtr->Write(bufs, [](auto bufs2, uv::Error) {
-          for (auto buf : bufs2) {
-            buf.Deallocate();
-          }
-        });
-      },
-      out);
-}
-
-static void CopyStream(uv::Stream& in, std::shared_ptr<uv::Stream> out) {
-  in.data.connect([out](uv::Buffer& buf, size_t len) {
-    uv::Buffer buf2 = buf.Dup();
-    buf2.len = len;
-    out->Write({buf2}, [](auto bufs, uv::Error) {
-      for (auto buf : bufs) {
-        buf.Deallocate();
-      }
-    });
-  });
-}
-
-int main(int argc, char* argv[]) {
-  // parse arguments
-  int programArgc = 1;
-  bool useUdp = false;
-  bool broadcastUdp = false;
-  bool err = false;
-
-  while (programArgc < argc && argv[programArgc][0] == '-') {
-    if (std::string_view(argv[programArgc]) == "-u") {
-      useUdp = true;
-    } else if (std::string_view(argv[programArgc]) == "-b") {
-      useUdp = true;
-      broadcastUdp = true;
-    } else {
-      fmt::print(stderr, "unrecognized command line option {}\n",
-                 argv[programArgc]);
-      err = true;
-    }
-    ++programArgc;
-  }
-
-  if (err || (argc - programArgc) < 1) {
-    std::fputs(argv[0], stderr);
-    std::fputs(
-        " [-ub] program [arguments ...]\n"
-        "  -u  send udp to localhost port 6666 instead of using tcp\n"
-        "  -b  broadcast udp to port 6666 instead of using tcp\n",
-        stderr);
-    return EXIT_FAILURE;
-  }
-
-  uv::Process::DisableStdioInheritance();
-
-  auto loop = uv::Loop::Create();
-  loop->error.connect(
-      [](uv::Error err) { fmt::print(stderr, "uv ERROR: {}\n", err.str()); });
-
-  // create pipes to communicate with child
-  auto stdinPipe = uv::Pipe::Create(loop);
-  auto stdoutPipe = uv::Pipe::Create(loop);
-  auto stderrPipe = uv::Pipe::Create(loop);
-
-  // create tty to pass from our console to child's
-  auto stdinTty = uv::Tty::Create(loop, 0, true);
-  auto stdoutTty = uv::Tty::Create(loop, 1, false);
-  auto stderrTty = uv::Tty::Create(loop, 2, false);
-
-  // pass through our console to child's (bidirectional)
-  if (stdinTty) {
-    CopyStream(*stdinTty, stdinPipe);
-  }
-  if (stdoutTty) {
-    CopyStream(*stdoutPipe, stdoutTty);
-  }
-  if (stderrTty) {
-    CopyStream(*stderrPipe, stderrTty);
-  }
-
-  // when our stdin closes, also close child stdin
-  if (stdinTty) {
-    stdinTty->end.connect([stdinPipe] { stdinPipe->Close(); });
-  }
-
-  if (useUdp) {
-    auto udp = uv::Udp::Create(loop);
-    // tee stdout and stderr
-    CopyUdp(*stdoutPipe, udp, broadcastUdp);
-    CopyUdp(*stderrPipe, udp, broadcastUdp);
-  } else {
-    auto tcp = uv::Tcp::Create(loop);
-
-    // bind to listen address and port
-    tcp->Bind("", 1740);
-
-    // when we get a connection, accept it
-    tcp->connection.connect([srv = tcp.get(), stdoutPipe, stderrPipe] {
-      auto tcp = srv->Accept();
-      if (!tcp) {
-        return;
-      }
-
-      // close on error
-      tcp->error.connect([s = tcp.get()](wpi::uv::Error err) { s->Close(); });
-
-      // tee stdout and stderr
-      CopyTcp(*stdoutPipe, tcp);
-      CopyTcp(*stderrPipe, tcp);
-    });
-
-    // start listening for incoming connections
-    tcp->Listen();
-  }
-
-  // build process options
-  wpi::SmallVector<uv::Process::Option, 8> options;
-
-  // hook up pipes to child
-  options.emplace_back(
-      uv::Process::StdioCreatePipe(0, *stdinPipe, UV_READABLE_PIPE));
-#ifndef _WIN32
-  // create a PTY so the child does unbuffered output
-  int parentfd, childfd;
-  if (openpty(&parentfd, &childfd, nullptr, nullptr, nullptr) == 0) {
-    stdoutPipe->Open(parentfd);
-    options.emplace_back(uv::Process::StdioInherit(1, childfd));
-  } else {
-    options.emplace_back(
-        uv::Process::StdioCreatePipe(1, *stdoutPipe, UV_WRITABLE_PIPE));
-  }
-#else
-  options.emplace_back(
-      uv::Process::StdioCreatePipe(1, *stdoutPipe, UV_WRITABLE_PIPE));
-#endif
-  options.emplace_back(
-      uv::Process::StdioCreatePipe(2, *stderrPipe, UV_WRITABLE_PIPE));
-
-  // pass our args as the child args (argv[1] becomes child argv[0], etc)
-  for (int i = programArgc; i < argc; ++i) {
-    options.emplace_back(argv[i]);
-  }
-
-  auto proc = uv::Process::SpawnArray(loop, argv[programArgc], options);
-  if (!proc) {
-    std::fputs("could not start subprocess\n", stderr);
-    return EXIT_FAILURE;
-  }
-  proc->exited.connect([](int64_t status, int) { std::exit(status); });
-
-  // start reading
-  if (stdinTty) {
-    stdinTty->StartRead();
-  }
-  stdoutPipe->StartRead();
-  stderrPipe->StartRead();
-
-  // pass various signals to child
-  auto sigHandler = [proc](int signum) { proc->Kill(signum); };
-  for (int signum : {SIGINT, SIGHUP, SIGTERM}) {
-    auto sig = uv::Signal::Create(loop);
-    sig->Start(signum);
-    sig->signal.connect(sigHandler);
-  }
-
-  // run the loop!
-  loop->Run();
-}
diff --git a/wpiutil/src/netconsoleTee/native/cpp/main.cpp b/wpiutil/src/netconsoleTee/native/cpp/main.cpp
deleted file mode 100644
index 8abb458..0000000
--- a/wpiutil/src/netconsoleTee/native/cpp/main.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include <cstdio>
-
-#include "fmt/format.h"
-#include "wpi/MathExtras.h"
-#include "wpi/SmallVector.h"
-#include "wpi/StringExtras.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/timestamp.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Tcp.h"
-#include "wpi/uv/Tty.h"
-#include "wpi/uv/Udp.h"
-#include "wpi/uv/util.h"
-
-namespace uv = wpi::uv;
-
-static uint64_t startTime = wpi::Now();
-
-static bool NewlineBuffer(std::string& rem, uv::Buffer& buf, size_t len,
-                          wpi::SmallVectorImpl<uv::Buffer>& bufs, bool tcp,
-                          uint16_t tcpSeq) {
-  // scan for last newline
-  std::string_view str(buf.base, len);
-  size_t idx = str.rfind('\n');
-  if (idx == std::string_view::npos) {
-    // no newline yet, just keep appending to remainder
-    rem += str;
-    return false;
-  }
-
-  // build output
-  wpi::raw_uv_ostream out(bufs, 4096);
-  std::string_view toCopy = wpi::slice(str, 0, idx + 1);
-  if (tcp) {
-    // Header is 2 byte len, 1 byte type, 4 byte timestamp, 2 byte sequence num
-    uint32_t ts = wpi::FloatToBits((wpi::Now() - startTime) * 1.0e-6);
-    uint16_t len = rem.size() + toCopy.size() + 1 + 4 + 2;
-    const uint8_t header[] = {static_cast<uint8_t>((len >> 8) & 0xff),
-                              static_cast<uint8_t>(len & 0xff),
-                              12,
-                              static_cast<uint8_t>((ts >> 24) & 0xff),
-                              static_cast<uint8_t>((ts >> 16) & 0xff),
-                              static_cast<uint8_t>((ts >> 8) & 0xff),
-                              static_cast<uint8_t>(ts & 0xff),
-                              static_cast<uint8_t>((tcpSeq >> 8) & 0xff),
-                              static_cast<uint8_t>(tcpSeq & 0xff)};
-    out << wpi::span<const uint8_t>(header);
-  }
-  out << rem << toCopy;
-
-  // reset remainder
-  rem = wpi::slice(str, idx + 1, std::string_view::npos);
-  return true;
-}
-
-static void CopyUdp(uv::Stream& in, std::shared_ptr<uv::Udp> out, int port,
-                    bool broadcast) {
-  sockaddr_in addr;
-  if (broadcast) {
-    out->SetBroadcast(true);
-    uv::NameToAddr("0.0.0.0", port, &addr);
-  } else {
-    uv::NameToAddr("127.0.0.1", port, &addr);
-  }
-
-  in.data.connect(
-      [rem = std::make_shared<std::string>(), outPtr = out.get(), addr](
-          uv::Buffer& buf, size_t len) {
-        // build buffers
-        wpi::SmallVector<uv::Buffer, 4> bufs;
-        if (!NewlineBuffer(*rem, buf, len, bufs, false, 0)) {
-          return;
-        }
-
-        // send output
-        outPtr->Send(addr, bufs, [](auto bufs2, uv::Error) {
-          for (auto buf : bufs2) {
-            buf.Deallocate();
-          }
-        });
-      },
-      out);
-}
-
-static void CopyTcp(uv::Stream& in, std::shared_ptr<uv::Stream> out) {
-  struct StreamData {
-    std::string rem;
-    uint16_t seq = 0;
-  };
-  in.data.connect(
-      [data = std::make_shared<StreamData>(), outPtr = out.get()](
-          uv::Buffer& buf, size_t len) {
-        // build buffers
-        wpi::SmallVector<uv::Buffer, 4> bufs;
-        if (!NewlineBuffer(data->rem, buf, len, bufs, true, data->seq++)) {
-          return;
-        }
-
-        // send output
-        outPtr->Write(bufs, [](auto bufs2, uv::Error) {
-          for (auto buf : bufs2) {
-            buf.Deallocate();
-          }
-        });
-      },
-      out);
-}
-
-static void CopyStream(uv::Stream& in, std::shared_ptr<uv::Stream> out) {
-  in.data.connect([out](uv::Buffer& buf, size_t len) {
-    uv::Buffer buf2 = buf.Dup();
-    buf2.len = len;
-    out->Write({buf2}, [](auto bufs, uv::Error) {
-      for (auto buf : bufs) {
-        buf.Deallocate();
-      }
-    });
-  });
-}
-
-int main(int argc, char* argv[]) {
-  // parse arguments
-  int arg = 1;
-  bool useUdp = false;
-  bool broadcastUdp = false;
-  bool err = false;
-  int port = -1;
-
-  while (arg < argc && argv[arg][0] == '-') {
-    if (std::string_view(argv[arg]) == "-u") {
-      useUdp = true;
-    } else if (std::string_view(argv[arg]) == "-b") {
-      useUdp = true;
-      broadcastUdp = true;
-    } else if (std::string_view(argv[arg]) == "-p") {
-      ++arg;
-      std::optional<int> portValue;
-      if (arg >= argc || argv[arg][0] == '-' ||
-          !(portValue = wpi::parse_integer<int>(argv[arg], 10))) {
-        std::fputs("-p must be followed by port number\n", stderr);
-        err = true;
-      } else if (portValue) {
-        port = portValue.value();
-      }
-    } else {
-      fmt::print(stderr, "unrecognized command line option {}\n", argv[arg]);
-      err = true;
-    }
-    ++arg;
-  }
-
-  if (err) {
-    std::fputs(argv[0], stderr);
-    std::fputs(
-        " [-ub] [-p PORT]\n"
-        "  -u       send udp to localhost port 6666 instead of using tcp\n"
-        "  -b       broadcast udp to port 6666 instead of using tcp\n"
-        "  -p PORT  use port PORT instead of 6666 (udp) or 1740 (tcp)\n",
-        stderr);
-    return EXIT_FAILURE;
-  }
-
-  auto loop = uv::Loop::Create();
-  loop->error.connect(
-      [](uv::Error err) { fmt::print(stderr, "uv ERROR: {}\n", err.str()); });
-
-  // create ttys
-  auto stdinTty = uv::Tty::Create(loop, 0, true);
-  auto stdoutTty = uv::Tty::Create(loop, 1, false);
-
-  // don't bother continuing if we don't have a stdin
-  if (!stdinTty) {
-    return EXIT_SUCCESS;
-  }
-
-  // pass through our input to output
-  if (stdoutTty) {
-    CopyStream(*stdinTty, stdoutTty);
-  }
-
-  // when our stdin closes, exit
-  stdinTty->end.connect([] { std::exit(EXIT_SUCCESS); });
-
-  if (useUdp) {
-    auto udp = uv::Udp::Create(loop);
-    // tee
-    CopyUdp(*stdinTty, udp, port < 0 ? 6666 : port, broadcastUdp);
-  } else {
-    auto tcp = uv::Tcp::Create(loop);
-
-    // bind to listen address and port
-    tcp->Bind("", port < 0 ? 1740 : port);
-
-    // when we get a connection, accept it
-    tcp->connection.connect([srv = tcp.get(), stdinTty] {
-      auto tcp = srv->Accept();
-      if (!tcp) {
-        return;
-      }
-
-      // close on error
-      tcp->error.connect([s = tcp.get()](wpi::uv::Error err) { s->Close(); });
-
-      // tee
-      CopyTcp(*stdinTty, tcp);
-    });
-
-    // start listening for incoming connections
-    tcp->Listen();
-  }
-
-  // start reading
-  if (stdinTty) {
-    stdinTty->StartRead();
-  }
-
-  // run the loop!
-  loop->Run();
-}
diff --git a/wpiutil/src/printlog/java/printlog/PrintLog.java b/wpiutil/src/printlog/java/printlog/PrintLog.java
new file mode 100644
index 0000000..e9339b6
--- /dev/null
+++ b/wpiutil/src/printlog/java/printlog/PrintLog.java
@@ -0,0 +1,150 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package printlog;
+
+import edu.wpi.first.util.datalog.DataLogReader;
+import edu.wpi.first.util.datalog.DataLogRecord;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.InputMismatchException;
+import java.util.Map;
+
+public final class PrintLog {
+  private static final DateTimeFormatter m_timeFormatter =
+      DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+  /** Main function. */
+  public static void main(String[] args) {
+    if (args.length != 1) {
+      System.err.println("Usage: printlog <file>");
+      System.exit(1);
+      return;
+    }
+    DataLogReader reader;
+    try {
+      reader = new DataLogReader(args[0]);
+    } catch (IOException ex) {
+      System.err.println("could not open file: " + ex.getMessage());
+      System.exit(1);
+      return;
+    }
+    if (!reader.isValid()) {
+      System.err.println("not a log file");
+      System.exit(1);
+      return;
+    }
+
+    Map<Integer, DataLogRecord.StartRecordData> entries = new HashMap<>();
+    for (DataLogRecord record : reader) {
+      if (record.isStart()) {
+        try {
+          DataLogRecord.StartRecordData data = record.getStartData();
+          System.out.println(
+              "Start("
+                  + data.entry
+                  + ", name='"
+                  + data.name
+                  + "', type='"
+                  + data.type
+                  + "', metadata='"
+                  + data.metadata
+                  + "') ["
+                  + (record.getTimestamp() / 1000000.0)
+                  + "]");
+          if (entries.containsKey(data.entry)) {
+            System.out.println("...DUPLICATE entry ID, overriding");
+          }
+          entries.put(data.entry, data);
+        } catch (InputMismatchException ex) {
+          System.out.println("Start(INVALID)");
+        }
+      } else if (record.isFinish()) {
+        try {
+          int entry = record.getFinishEntry();
+          System.out.println("Finish(" + entry + ") [" + (record.getTimestamp() / 1000000.0) + "]");
+          if (!entries.containsKey(entry)) {
+            System.out.println("...ID not found");
+          } else {
+            entries.remove(entry);
+          }
+        } catch (InputMismatchException ex) {
+          System.out.println("Finish(INVALID)");
+        }
+      } else if (record.isSetMetadata()) {
+        try {
+          DataLogRecord.MetadataRecordData data = record.getSetMetadataData();
+          System.out.println(
+              "SetMetadata("
+                  + data.entry
+                  + ", '"
+                  + data.metadata
+                  + "') ["
+                  + (record.getTimestamp() / 1000000.0)
+                  + "]");
+          if (!entries.containsKey(data.entry)) {
+            System.out.println("...ID not found");
+          }
+        } catch (InputMismatchException ex) {
+          System.out.println("SetMetadata(INVALID)");
+        }
+      } else if (record.isControl()) {
+        System.out.println("Unrecognized control record");
+      } else {
+        System.out.print("Data(" + record.getEntry() + ", size=" + record.getSize() + ") ");
+        DataLogRecord.StartRecordData entry = entries.get(record.getEntry());
+        if (entry == null) {
+          System.out.println("<ID not found>");
+          continue;
+        }
+        System.out.println(
+            "<name='"
+                + entry.name
+                + "', type='"
+                + entry.type
+                + "'> ["
+                + (record.getTimestamp() / 1000000.0)
+                + "]");
+
+        try {
+          // handle systemTime specially
+          if ("systemTime".equals(entry.name) && "int64".equals(entry.type)) {
+            long val = record.getInteger();
+            System.out.println(
+                "  "
+                    + m_timeFormatter.format(
+                        LocalDateTime.ofEpochSecond(val / 1000000, 0, ZoneOffset.UTC))
+                    + "."
+                    + String.format("%06d", val % 1000000));
+            continue;
+          }
+
+          if ("double".equals(entry.type)) {
+            System.out.println("  " + record.getDouble());
+          } else if ("int64".equals(entry.type)) {
+            System.out.println("  " + record.getInteger());
+          } else if ("string".equals(entry.type) || "json".equals(entry.type)) {
+            System.out.println("  '" + record.getString() + "'");
+          } else if ("boolean".equals(entry.type)) {
+            System.out.println("  " + record.getBoolean());
+          } else if ("double[]".equals(entry.type)) {
+            System.out.println("  " + Arrays.asList(record.getDoubleArray()));
+          } else if ("int64[]".equals(entry.type)) {
+            System.out.println("  " + Arrays.asList(record.getIntegerArray()));
+          } else if ("string[]".equals(entry.type)) {
+            System.out.println("  " + Arrays.asList(record.getStringArray()));
+          }
+        } catch (InputMismatchException ex) {
+          System.out.println("  invalid");
+        }
+      }
+    }
+  }
+
+  private PrintLog() {}
+}
diff --git a/wpiutil/src/test/java/edu/wpi/first/util/ErrorMessagesTest.java b/wpiutil/src/test/java/edu/wpi/first/util/ErrorMessagesTest.java
new file mode 100644
index 0000000..94e8bea
--- /dev/null
+++ b/wpiutil/src/test/java/edu/wpi/first/util/ErrorMessagesTest.java
@@ -0,0 +1,24 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util;
+
+import static edu.wpi.first.util.ErrorMessages.requireNonNullParam;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+class ErrorMessagesTest {
+  @Test
+  void requireNonNullParamNullTest() {
+    assertThrows(
+        NullPointerException.class, () -> requireNonNullParam(null, "testParam", "testMethod"));
+  }
+
+  @Test
+  void requireNonNullParamNotNullTest() {
+    assertDoesNotThrow(() -> requireNonNullParam("null", "testParam", "testMethod"));
+  }
+}
diff --git a/wpiutil/src/test/java/edu/wpi/first/util/InterpolatingTreeMapTest.java b/wpiutil/src/test/java/edu/wpi/first/util/InterpolatingTreeMapTest.java
new file mode 100644
index 0000000..ea23dc5
--- /dev/null
+++ b/wpiutil/src/test/java/edu/wpi/first/util/InterpolatingTreeMapTest.java
@@ -0,0 +1,134 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package edu.wpi.first.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class InterpolatingTreeMapTest {
+  @Test
+  void testInterpolationDouble() {
+    InterpolatingTreeMap<Double, Double> table = new InterpolatingTreeMap<>();
+
+    table.put(125.0, 450.0);
+    table.put(200.0, 510.0);
+    table.put(268.0, 525.0);
+    table.put(312.0, 550.0);
+    table.put(326.0, 650.0);
+
+    // Key below minimum gives the smallest value
+    assertEquals(450.0, table.get(100.0));
+
+    // Minimum key gives exact value
+    assertEquals(450.0, table.get(125.0));
+
+    // Key gives interpolated value
+    assertEquals(480.0, table.get(162.5));
+
+    // Key at right of interpolation range gives exact value
+    assertEquals(510.0, table.get(200.0));
+
+    // Maximum key gives exact value
+    assertEquals(650.0, table.get(326.0));
+
+    // Key above maximum gives largest value
+    assertEquals(650.0, table.get(400.0));
+  }
+
+  @Test
+  void testInterpolationClear() {
+    InterpolatingTreeMap<Double, Double> table = new InterpolatingTreeMap<>();
+
+    table.put(125.0, 450.0);
+    table.put(200.0, 510.0);
+    table.put(268.0, 525.0);
+    table.put(312.0, 550.0);
+    table.put(326.0, 650.0);
+
+    // Key below minimum gives the smallest value
+    assertEquals(450.0, table.get(100.0));
+
+    // Minimum key gives exact value
+    assertEquals(450.0, table.get(125.0));
+
+    // Key gives interpolated value
+    assertEquals(480.0, table.get(162.5));
+
+    // Key at right of interpolation range gives exact value
+    assertEquals(510.0, table.get(200.0));
+
+    // Maximum key gives exact value
+    assertEquals(650.0, table.get(326.0));
+
+    // Key above maximum gives largest value
+    assertEquals(650.0, table.get(400.0));
+
+    table.clear();
+
+    table.put(100.0, 250.0);
+    table.put(200.0, 500.0);
+
+    assertEquals(375.0, table.get(150.0));
+  }
+
+  @Test
+  void testInterpolationInteger() {
+    InterpolatingTreeMap<Integer, Integer> table = new InterpolatingTreeMap<>();
+
+    table.put(125, 450);
+    table.put(200, 510);
+    table.put(268, 525);
+    table.put(312, 550);
+    table.put(326, 650);
+
+    // Key below minimum gives the smallest value
+    assertEquals(450.0, table.get(100));
+
+    // Minimum key gives exact value
+    assertEquals(450.0, table.get(125));
+
+    // Key gives interpolated value
+    assertEquals(479.6, table.get(162));
+
+    // Key at right of interpolation range gives exact value
+    assertEquals(510.0, table.get(200));
+
+    // Maximum key gives exact value
+    assertEquals(650.0, table.get(326));
+
+    // Key above maximum gives largest value
+    assertEquals(650.0, table.get(400));
+  }
+
+  @Test
+  void testInterpolationLong() {
+    InterpolatingTreeMap<Long, Long> table = new InterpolatingTreeMap<>();
+
+    table.put(125L, 450L);
+    table.put(200L, 510L);
+    table.put(268L, 525L);
+    table.put(312L, 550L);
+    table.put(326L, 650L);
+
+    // Key below minimum gives the smallest value
+    assertEquals(450.0, table.get(100L));
+
+    // Minimum key gives exact value
+    assertEquals(450.0, table.get(125L));
+
+    // Key gives interpolated value
+    assertEquals(479.6, table.get(162L));
+
+    // Key at right of interpolation range gives exact value
+    assertEquals(510.0, table.get(200L));
+
+    // Maximum key gives exact value
+    assertEquals(650.0, table.get(326L));
+
+    // Key above maximum gives largest value
+    assertEquals(650.0, table.get(400L));
+  }
+}
diff --git a/wpiutil/src/test/native/ManagedStaticTest.cpp b/wpiutil/src/test/native/ManagedStaticTest.cpp
deleted file mode 100644
index ab54499..0000000
--- a/wpiutil/src/test/native/ManagedStaticTest.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/ManagedStatic.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"
-
-static int refCount = 0;
-
-struct StaticTestClass {
-  StaticTestClass() { refCount++; }
-  ~StaticTestClass() { refCount--; }
-
-  void Func() {}
-};
-
-namespace wpi {
-TEST(ManagedStaticTest, LazyDoesNotInitialize) {
-  {
-    refCount = 0;
-    wpi::ManagedStatic<StaticTestClass> managedStatic;
-    (void)managedStatic;
-    ASSERT_EQ(refCount, 0);
-  }
-  ASSERT_EQ(refCount, 0);
-  wpi_shutdown();
-}
-
-TEST(ManagedStaticTest, LazyInitDoesntDestruct) {
-  {
-    refCount = 0;
-    wpi::ManagedStatic<StaticTestClass> managedStatic;
-    ASSERT_EQ(refCount, 0);
-    managedStatic->Func();
-    ASSERT_EQ(refCount, 1);
-  }
-  ASSERT_EQ(refCount, 1);
-  wpi_shutdown();
-  ASSERT_EQ(refCount, 0);
-}
-
-TEST(ManagedStaticTest, EagerInit) {
-  {
-    refCount = 0;
-    StaticTestClass* test = new StaticTestClass{};
-    ASSERT_EQ(refCount, 1);  // NOLINT
-    wpi::ManagedStatic<StaticTestClass> managedStatic(
-        test, [](void* val) { delete static_cast<StaticTestClass*>(val); });
-    ASSERT_EQ(refCount, 1);
-    managedStatic->Func();
-    ASSERT_EQ(refCount, 1);
-  }
-  ASSERT_EQ(refCount, 1);
-  wpi_shutdown();
-  ASSERT_EQ(refCount, 0);
-}
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/ArrayTest.cpp b/wpiutil/src/test/native/cpp/ArrayTest.cpp
index 15e1928..1f28157 100644
--- a/wpiutil/src/test/native/cpp/ArrayTest.cpp
+++ b/wpiutil/src/test/native/cpp/ArrayTest.cpp
@@ -15,16 +15,20 @@
 }  // namespace
 
 TEST(ArrayTest, CopyableTypeCompiles) {
-  wpi::array<int, 3> arr1{1, 2, 3};
+  constexpr wpi::array<int, 3> arr1{1, 2, 3};
+  static_cast<void>(arr1);
 
   // Test deduction guide
-  wpi::array ar2{1, 2, 3};
+  constexpr wpi::array arr2{1, 2, 3};
+  static_cast<void>(arr2);
 }
 
 TEST(ArrayTest, MoveOnlyTypeCompiles) {
-  wpi::array<MoveOnlyType, 3> arr1{MoveOnlyType{}, MoveOnlyType{},
-                                   MoveOnlyType{}};
+  constexpr wpi::array<MoveOnlyType, 3> arr1{MoveOnlyType{}, MoveOnlyType{},
+                                             MoveOnlyType{}};
+  static_cast<void>(arr1);
 
   // Test deduction guide
-  wpi::array arr2{MoveOnlyType{}, MoveOnlyType{}, MoveOnlyType{}};
+  constexpr wpi::array arr2{MoveOnlyType{}, MoveOnlyType{}, MoveOnlyType{}};
+  static_cast<void>(arr2);
 }
diff --git a/wpiutil/src/test/native/cpp/HttpParserTest.cpp b/wpiutil/src/test/native/cpp/HttpParserTest.cpp
deleted file mode 100644
index 281abd0..0000000
--- a/wpiutil/src/test/native/cpp/HttpParserTest.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpParser.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"
-
-namespace wpi {
-
-TEST(HttpParserTest, UrlMethodHeadersComplete) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.url.connect([&](std::string_view path) {
-    ASSERT_EQ(path, "/foo/bar");
-    ASSERT_EQ(p.GetUrl(), "/foo/bar");
-    ++callbacks;
-  });
-  p.Execute("GET /foo");
-  p.Execute("/bar");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute(" HTTP/1.1\r\n\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_EQ(p.GetUrl(), "/foo/bar");
-  ASSERT_EQ(p.GetMethod(), HTTP_GET);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, UrlMethodHeader) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.url.connect([&](std::string_view path) {
-    ASSERT_EQ(path, "/foo/bar");
-    ASSERT_EQ(p.GetUrl(), "/foo/bar");
-    ++callbacks;
-  });
-  p.Execute("GET /foo");
-  p.Execute("/bar");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute(" HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("F");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_EQ(p.GetUrl(), "/foo/bar");
-  ASSERT_EQ(p.GetMethod(), HTTP_GET);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, StatusHeadersComplete) {
-  HttpParser p{HttpParser::kResponse};
-  int callbacks = 0;
-  p.status.connect([&](std::string_view status) {
-    ASSERT_EQ(status, "OK");
-    ASSERT_EQ(p.GetStatusCode(), 200u);
-    ++callbacks;
-  });
-  p.Execute("HTTP/1.1 200");
-  p.Execute(" OK");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_EQ(p.GetStatusCode(), 200u);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, StatusHeader) {
-  HttpParser p{HttpParser::kResponse};
-  int callbacks = 0;
-  p.status.connect([&](std::string_view status) {
-    ASSERT_EQ(status, "OK");
-    ASSERT_EQ(p.GetStatusCode(), 200u);
-    ++callbacks;
-  });
-  p.Execute("HTTP/1.1 200");
-  p.Execute(" OK\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("F");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_EQ(p.GetStatusCode(), 200u);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeaderFieldComplete) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.header.connect([&](std::string_view name, std::string_view value) {
-    ASSERT_EQ(name, "Foo");
-    ASSERT_EQ(value, "Bar");
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Fo");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("o: ");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Bar");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeaderFieldNext) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.header.connect([&](std::string_view name, std::string_view value) {
-    ASSERT_EQ(name, "Foo");
-    ASSERT_EQ(value, "Bar");
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Fo");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("o: ");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Bar");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("F");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeadersComplete) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.headersComplete.connect([&](bool keepAlive) {
-    ASSERT_EQ(keepAlive, false);
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.0\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeadersCompleteHTTP11) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.headersComplete.connect([&](bool keepAlive) {
-    ASSERT_EQ(keepAlive, true);
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeadersCompleteKeepAlive) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.headersComplete.connect([&](bool keepAlive) {
-    ASSERT_EQ(keepAlive, true);
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.0\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Connection: Keep-Alive\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, HeadersCompleteUpgrade) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.headersComplete.connect([&](bool) {
-    ASSERT_TRUE(p.IsUpgrade());
-    ++callbacks;
-  });
-  p.Execute("GET / HTTP/1.0\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("Connection: Upgrade\r\n");
-  p.Execute("Upgrade: websocket\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  ASSERT_FALSE(p.HasError());
-}
-
-TEST(HttpParserTest, Reset) {
-  HttpParser p{HttpParser::kRequest};
-  int callbacks = 0;
-  p.headersComplete.connect([&](bool) { ++callbacks; });
-  p.Execute("GET / HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 0);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 1);
-  p.Reset(HttpParser::kRequest);
-  p.Execute("GET / HTTP/1.1\r\n");
-  ASSERT_EQ(callbacks, 1);
-  p.Execute("\r\n");
-  ASSERT_EQ(callbacks, 2);
-  ASSERT_FALSE(p.HasError());
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/HttpUtilTest.cpp b/wpiutil/src/test/native/cpp/HttpUtilTest.cpp
deleted file mode 100644
index 524086a..0000000
--- a/wpiutil/src/test/native/cpp/HttpUtilTest.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpUtil.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"
-
-namespace wpi {
-
-TEST(HttpMultipartScannerTest, ExecuteExact) {
-  HttpMultipartScanner scanner("foo");
-  EXPECT_TRUE(scanner.Execute("abcdefg---\r\n--foo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_TRUE(scanner.GetSkipped().empty());
-}
-
-TEST(HttpMultipartScannerTest, ExecutePartial) {
-  HttpMultipartScanner scanner("foo");
-  EXPECT_TRUE(scanner.Execute("abcdefg--").empty());
-  EXPECT_FALSE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("-\r\n").empty());
-  EXPECT_FALSE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("--foo\r").empty());
-  EXPECT_FALSE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, ExecuteTrailing) {
-  HttpMultipartScanner scanner("foo");
-  EXPECT_EQ(scanner.Execute("abcdefg---\r\n--foo\r\nxyz"), "xyz");
-}
-
-TEST(HttpMultipartScannerTest, ExecutePadding) {
-  HttpMultipartScanner scanner("foo");
-  EXPECT_EQ(scanner.Execute("abcdefg---\r\n--foo    \r\nxyz"), "xyz");
-  EXPECT_TRUE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, SaveSkipped) {
-  HttpMultipartScanner scanner("foo", true);
-  scanner.Execute("abcdefg---\r\n--foo\r\n");
-  EXPECT_EQ(scanner.GetSkipped(), "abcdefg---\r\n--foo\r\n");
-}
-
-TEST(HttpMultipartScannerTest, Reset) {
-  HttpMultipartScanner scanner("foo", true);
-
-  scanner.Execute("abcdefg---\r\n--foo\r\n");
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_EQ(scanner.GetSkipped(), "abcdefg---\r\n--foo\r\n");
-
-  scanner.Reset(true);
-  EXPECT_FALSE(scanner.IsDone());
-  scanner.SetBoundary("bar");
-
-  scanner.Execute("--foo\r\n--bar\r\n");
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_EQ(scanner.GetSkipped(), "--foo\r\n--bar\r\n");
-}
-
-TEST(HttpMultipartScannerTest, WithoutDashes) {
-  HttpMultipartScanner scanner("foo", true);
-
-  EXPECT_TRUE(scanner.Execute("--\r\nfoo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, SeqDashesDashes) {
-  HttpMultipartScanner scanner("foo", true);
-  EXPECT_TRUE(scanner.Execute("\r\n--foo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("\r\n--foo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, SeqDashesNoDashes) {
-  HttpMultipartScanner scanner("foo", true);
-  EXPECT_TRUE(scanner.Execute("\r\n--foo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("\r\nfoo\r\n").empty());
-  EXPECT_FALSE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, SeqNoDashesDashes) {
-  HttpMultipartScanner scanner("foo", true);
-  EXPECT_TRUE(scanner.Execute("\r\nfoo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("\r\n--foo\r\n").empty());
-  EXPECT_FALSE(scanner.IsDone());
-}
-
-TEST(HttpMultipartScannerTest, SeqNoDashesNoDashes) {
-  HttpMultipartScanner scanner("foo", true);
-  EXPECT_TRUE(scanner.Execute("\r\nfoo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-  EXPECT_TRUE(scanner.Execute("\r\nfoo\r\n").empty());
-  EXPECT_TRUE(scanner.IsDone());
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/HttpWebSocketServerConnectionTest.cpp b/wpiutil/src/test/native/cpp/HttpWebSocketServerConnectionTest.cpp
deleted file mode 100644
index 18a21be..0000000
--- a/wpiutil/src/test/native/cpp/HttpWebSocketServerConnectionTest.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/HttpWebSocketServerConnection.h"  // NOLINT(build/include_order)
-
-#include <gtest/gtest.h>
-
-namespace wpi {
-
-class HttpWebSocketServerConnectionTest
-    : public HttpWebSocketServerConnection<HttpWebSocketServerConnectionTest> {
- public:
-  HttpWebSocketServerConnectionTest(std::shared_ptr<uv::Stream> stream,
-                                    span<const std::string_view> protocols)
-      : HttpWebSocketServerConnection{stream, protocols} {}
-
-  void ProcessRequest() override { ++gotRequest; }
-  void ProcessWsUpgrade() override { ++gotUpgrade; }
-
-  int gotRequest = 0;
-  int gotUpgrade = 0;
-};
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/InterpolatingMapTest.cpp b/wpiutil/src/test/native/cpp/InterpolatingMapTest.cpp
new file mode 100644
index 0000000..4479da5
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/InterpolatingMapTest.cpp
@@ -0,0 +1,52 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "wpi/interpolating_map.h"  // NOLINT(build/include_order)
+
+#include <gtest/gtest.h>
+
+TEST(InterpolatingMapTest, Insert) {
+  wpi::interpolating_map<double, double> table;
+
+  table.insert(125, 450);
+  table.insert(200, 510);
+  table.insert(268, 525);
+  table.insert(312, 550);
+  table.insert(326, 650);
+
+  // Key below minimum gives smallest value
+  EXPECT_EQ(450, table[100]);
+
+  // Minimum key gives exact value
+  EXPECT_EQ(450, table[125]);
+
+  // Key gives interpolated value
+  EXPECT_EQ(480, table[162.5]);
+
+  // Key at right of interpolation range gives exact value
+  EXPECT_EQ(510, table[200]);
+
+  // Maximum key gives exact value
+  EXPECT_EQ(650, table[326]);
+
+  // Key above maximum gives largest value
+  EXPECT_EQ(650, table[400]);
+}
+
+TEST(InterpolatingMapTest, Clear) {
+  wpi::interpolating_map<double, double> table;
+
+  table.insert(125, 450);
+  table.insert(200, 510);
+  table.insert(268, 525);
+  table.insert(312, 550);
+  table.insert(326, 650);
+
+  table.clear();
+
+  table.insert(100, 250);
+  table.insert(200, 500);
+
+  EXPECT_EQ(375, table[150]);
+}
diff --git a/wpiutil/src/test/native/cpp/ScopeExitTest.cpp b/wpiutil/src/test/native/cpp/ScopeExitTest.cpp
new file mode 100644
index 0000000..9cecb1c
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/ScopeExitTest.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "gtest/gtest.h"
+#include "wpi/scope"
+
+TEST(ScopeExitTest, ScopeExit) {
+  int exitCount = 0;
+
+  {
+    wpi::scope_exit exit{[&] { ++exitCount; }};
+
+    EXPECT_EQ(0, exitCount);
+  }
+
+  EXPECT_EQ(1, exitCount);
+}
+
+TEST(ScopeExitTest, Release) {
+  int exitCount = 0;
+
+  {
+    wpi::scope_exit exit1{[&] { ++exitCount; }};
+    wpi::scope_exit exit2 = std::move(exit1);
+    wpi::scope_exit exit3 = std::move(exit1);
+    EXPECT_EQ(0, exitCount);
+  }
+  EXPECT_EQ(1, exitCount);
+
+  {
+    wpi::scope_exit exit{[&] { ++exitCount; }};
+    exit.release();
+  }
+  EXPECT_EQ(1, exitCount);
+}
diff --git a/wpiutil/src/test/native/cpp/UnescapeCStringTest.cpp b/wpiutil/src/test/native/cpp/UnescapeCStringTest.cpp
new file mode 100644
index 0000000..7f0ca5f
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/UnescapeCStringTest.cpp
@@ -0,0 +1,74 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "gtest/gtest.h"
+#include "wpi/SmallString.h"
+#include "wpi/StringExtras.h"
+
+using namespace wpi;
+
+namespace {
+
+TEST(UnescapeCStringTest, Basic) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("abc\\\\\\a\\b\\f\\n\\r\\t\\v\\", buf);
+  EXPECT_EQ(out, "abc\\\a\b\f\n\r\t\v\\");
+  EXPECT_TRUE(rem.empty());
+}
+
+TEST(UnescapeCStringTest, QuoteEnd) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("abc\\\"\"123", buf);
+  EXPECT_EQ(out, "abc\"");
+  EXPECT_EQ(rem, "\"123");
+}
+
+TEST(UnescapeCStringTest, Hex) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("\\xfe\\xFE\\x01", buf);
+  EXPECT_EQ(out, "\xfe\xFE\x01");
+  EXPECT_TRUE(rem.empty());
+}
+
+TEST(UnescapeCStringTest, HexPartial) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("\\xz\\x5z\\x2", buf);
+  EXPECT_EQ(out, "xz\x05z\x02");
+  EXPECT_TRUE(rem.empty());
+}
+
+TEST(UnescapeCStringTest, HexPartial2) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("\\x", buf);
+  EXPECT_EQ(out, "x");
+  EXPECT_TRUE(rem.empty());
+}
+
+TEST(UnescapeCStringTest, Octal) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("\\3\\11\\222\\4", buf);
+  EXPECT_EQ(out, "\3\11\222\4");
+  EXPECT_TRUE(rem.empty());
+}
+
+TEST(UnescapeCStringTest, EmptyString) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("", buf);
+  EXPECT_EQ(out, "");
+}
+
+TEST(UnescapeCStringTest, ShortString) {
+  SmallString<64> buf;
+  auto [out, rem] = UnescapeCString("a", buf);
+  EXPECT_EQ(out, "a");
+}
+
+TEST(UnescapeCStringTest, NoEscapesString) {
+  SmallString<64> buf;
+  std::string_view input = "abcdefghijklmnopqrstuvwxyz1234567890";
+  auto [out, rem] = UnescapeCString(input, buf);
+  EXPECT_EQ(out, input);
+}
+
+}  // namespace
diff --git a/wpiutil/src/test/native/cpp/WebSocketClientTest.cpp b/wpiutil/src/test/native/cpp/WebSocketClientTest.cpp
deleted file mode 100644
index 9d85e66..0000000
--- a/wpiutil/src/test/native/cpp/WebSocketClientTest.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocket.h"  // NOLINT(build/include_order)
-
-#include "WebSocketTest.h"
-#include "wpi/Base64.h"
-#include "wpi/HttpParser.h"
-#include "wpi/SmallString.h"
-#include "wpi/StringExtras.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/sha1.h"
-
-namespace wpi {
-
-class WebSocketClientTest : public WebSocketTest {
- public:
-  WebSocketClientTest() {
-    // Bare bones server
-    req.header.connect([this](std::string_view name, std::string_view value) {
-      // save key (required for valid response)
-      if (equals_lower(name, "sec-websocket-key")) {
-        clientKey = value;
-      }
-    });
-    req.headersComplete.connect([this](bool) {
-      // send response
-      SmallVector<uv::Buffer, 4> bufs;
-      raw_uv_ostream os{bufs, 4096};
-      os << "HTTP/1.1 101 Switching Protocols\r\n";
-      os << "Upgrade: websocket\r\n";
-      os << "Connection: Upgrade\r\n";
-
-      // accept hash
-      SHA1 hash;
-      hash.Update(clientKey);
-      hash.Update("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
-      if (mockBadAccept) {
-        hash.Update("1");
-      }
-      SmallString<64> hashBuf;
-      SmallString<64> acceptBuf;
-      os << "Sec-WebSocket-Accept: "
-         << Base64Encode(hash.RawFinal(hashBuf), acceptBuf) << "\r\n";
-
-      if (!mockProtocol.empty()) {
-        os << "Sec-WebSocket-Protocol: " << mockProtocol << "\r\n";
-      }
-
-      os << "\r\n";
-
-      conn->Write(bufs, [](auto bufs, uv::Error) {
-        for (auto& buf : bufs) {
-          buf.Deallocate();
-        }
-      });
-
-      serverHeadersDone = true;
-      if (connected) {
-        connected();
-      }
-    });
-
-    serverPipe->Listen([this] {
-      conn = serverPipe->Accept();
-      conn->StartRead();
-      conn->data.connect([this](uv::Buffer& buf, size_t size) {
-        std::string_view data{buf.base, size};
-        if (!serverHeadersDone) {
-          data = req.Execute(data);
-          if (req.HasError()) {
-            Finish();
-          }
-          ASSERT_EQ(req.GetError(), HPE_OK) << http_errno_name(req.GetError());
-          if (data.empty()) {
-            return;
-          }
-        }
-        wireData.insert(wireData.end(), data.begin(), data.end());
-      });
-      conn->end.connect([this] { Finish(); });
-    });
-  }
-
-  bool mockBadAccept = false;
-  std::vector<uint8_t> wireData;
-  std::shared_ptr<uv::Pipe> conn;
-  HttpParser req{HttpParser::kRequest};
-  SmallString<64> clientKey;
-  std::string mockProtocol;
-  bool serverHeadersDone = false;
-  std::function<void()> connected;
-};
-
-TEST_F(WebSocketClientTest, Open) {
-  int gotOpen = 0;
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << " Reason: " << reason;
-      }
-    });
-    ws->open.connect([&](std::string_view protocol) {
-      ++gotOpen;
-      Finish();
-      ASSERT_TRUE(protocol.empty());
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotOpen, 1);
-}
-
-TEST_F(WebSocketClientTest, BadAccept) {
-  int gotClosed = 0;
-
-  mockBadAccept = true;
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view msg) {
-      Finish();
-      ++gotClosed;
-      ASSERT_EQ(code, 1002) << "Message: " << msg;
-    });
-    ws->open.connect([&](std::string_view protocol) {
-      Finish();
-      FAIL() << "Got open";
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketClientTest, ProtocolGood) {
-  int gotOpen = 0;
-
-  mockProtocol = "myProtocol";
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName,
-                                      {"myProtocol", "myProtocol2"});
-    ws->closed.connect([&](uint16_t code, std::string_view msg) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << "Message: " << msg;
-      }
-    });
-    ws->open.connect([&](std::string_view protocol) {
-      ++gotOpen;
-      Finish();
-      ASSERT_EQ(protocol, "myProtocol");
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotOpen, 1);
-}
-
-TEST_F(WebSocketClientTest, ProtocolRespNotReq) {
-  int gotClosed = 0;
-
-  mockProtocol = "myProtocol";
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view msg) {
-      Finish();
-      ++gotClosed;
-      ASSERT_EQ(code, 1003) << "Message: " << msg;
-    });
-    ws->open.connect([&](std::string_view protocol) {
-      Finish();
-      FAIL() << "Got open";
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketClientTest, ProtocolReqNotResp) {
-  int gotClosed = 0;
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName,
-                                      {{"myProtocol"}});
-    ws->closed.connect([&](uint16_t code, std::string_view msg) {
-      Finish();
-      ++gotClosed;
-      ASSERT_EQ(code, 1002) << "Message: " << msg;
-    });
-    ws->open.connect([&](std::string_view protocol) {
-      Finish();
-      FAIL() << "Got open";
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotClosed, 1);
-}
-
-//
-// Send and receive data.  Most of these cases are tested in
-// WebSocketServerTest, so only spot check differences like masking.
-//
-
-class WebSocketClientDataTest : public WebSocketClientTest,
-                                public ::testing::WithParamInterface<size_t> {
- public:
-  WebSocketClientDataTest() {
-    clientPipe->Connect(pipeName, [&] {
-      ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-      if (setupWebSocket) {
-        setupWebSocket();
-      }
-    });
-  }
-
-  std::function<void()> setupWebSocket;
-  std::shared_ptr<WebSocket> ws;
-};
-
-INSTANTIATE_TEST_SUITE_P(WebSocketClientDataTests, WebSocketClientDataTest,
-                         ::testing::Values(0, 1, 125, 126, 65535, 65536));
-
-TEST_P(WebSocketClientDataTest, SendBinary) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) {
-      ws->SendBinary({{data}}, [&](auto bufs, uv::Error) {
-        ++gotCallback;
-        ws->Terminate();
-        ASSERT_FALSE(bufs.empty());
-        ASSERT_EQ(bufs[0].base, reinterpret_cast<const char*>(data.data()));
-      });
-    });
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x02, true, true, data);
-  AdjustMasking(wireData);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketClientDataTest, ReceiveBinary) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->binary.connect([&](auto inData, bool fin) {
-      ++gotCallback;
-      ws->Terminate();
-      ASSERT_TRUE(fin);
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      ASSERT_EQ(data, recvData);
-    });
-  };
-  auto message = BuildMessage(0x02, true, false, data);
-  connected = [&] { conn->Write({{message}}, [&](auto bufs, uv::Error) {}); };
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-//
-// The client must close the connection if a masked frame is received.
-//
-
-TEST_P(WebSocketClientDataTest, ReceiveMasked) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), ' ');
-  setupWebSocket = [&] {
-    ws->text.connect([&](std::string_view, bool) {
-      ws->Terminate();
-      FAIL() << "Should not have gotten masked message";
-    });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, true, true, data);
-  connected = [&] { conn->Write({{message}}, [&](auto bufs, uv::Error) {}); };
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/WebSocketIntegrationTest.cpp b/wpiutil/src/test/native/cpp/WebSocketIntegrationTest.cpp
deleted file mode 100644
index 3de75d9..0000000
--- a/wpiutil/src/test/native/cpp/WebSocketIntegrationTest.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocketServer.h"  // NOLINT(build/include_order)
-
-#include "WebSocketTest.h"
-#include "wpi/HttpParser.h"
-#include "wpi/SmallString.h"
-
-namespace wpi {
-
-class WebSocketIntegrationTest : public WebSocketTest {};
-
-TEST_F(WebSocketIntegrationTest, Open) {
-  int gotServerOpen = 0;
-  int gotClientOpen = 0;
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto server = WebSocketServer::Create(*conn);
-    server->connected.connect([&](std::string_view url, WebSocket&) {
-      ++gotServerOpen;
-      ASSERT_EQ(url, "/test");
-    });
-  });
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << " Reason: " << reason;
-      }
-    });
-    ws->open.connect([&, s = ws.get()](std::string_view) {
-      ++gotClientOpen;
-      s->Close();
-    });
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotServerOpen, 1);
-  ASSERT_EQ(gotClientOpen, 1);
-}
-
-TEST_F(WebSocketIntegrationTest, Protocol) {
-  int gotServerOpen = 0;
-  int gotClientOpen = 0;
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto server = WebSocketServer::Create(*conn, {"proto1", "proto2"});
-    server->connected.connect([&](std::string_view, WebSocket& ws) {
-      ++gotServerOpen;
-      ASSERT_EQ(ws.GetProtocol(), "proto1");
-    });
-  });
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws =
-        WebSocket::CreateClient(*clientPipe, "/test", pipeName, {"proto1"});
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << " Reason: " << reason;
-      }
-    });
-    ws->open.connect([&, s = ws.get()](std::string_view protocol) {
-      ++gotClientOpen;
-      s->Close();
-      ASSERT_EQ(protocol, "proto1");
-    });
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotServerOpen, 1);
-  ASSERT_EQ(gotClientOpen, 1);
-}
-
-TEST_F(WebSocketIntegrationTest, ServerSendBinary) {
-  int gotData = 0;
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto server = WebSocketServer::Create(*conn);
-    server->connected.connect([&](std::string_view, WebSocket& ws) {
-      ws.SendBinary({uv::Buffer{"\x03\x04", 2}}, [&](auto, uv::Error) {});
-      ws.Close();
-    });
-  });
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << " Reason: " << reason;
-      }
-    });
-    ws->binary.connect([&](auto data, bool) {
-      ++gotData;
-      std::vector<uint8_t> recvData{data.begin(), data.end()};
-      std::vector<uint8_t> expectData{0x03, 0x04};
-      ASSERT_EQ(recvData, expectData);
-    });
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotData, 1);
-}
-
-TEST_F(WebSocketIntegrationTest, ClientSendText) {
-  int gotData = 0;
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto server = WebSocketServer::Create(*conn);
-    server->connected.connect([&](std::string_view, WebSocket& ws) {
-      ws.text.connect([&](std::string_view data, bool) {
-        ++gotData;
-        ASSERT_EQ(data, "hello");
-      });
-    });
-  });
-
-  clientPipe->Connect(pipeName, [&] {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      Finish();
-      if (code != 1005 && code != 1006) {
-        FAIL() << "Code: " << code << " Reason: " << reason;
-      }
-    });
-    ws->open.connect([&, s = ws.get()](std::string_view) {
-      s->SendText({{"hello"}}, [&](auto, uv::Error) {});
-      s->Close();
-    });
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotData, 1);
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/WebSocketServerTest.cpp b/wpiutil/src/test/native/cpp/WebSocketServerTest.cpp
deleted file mode 100644
index 83561bf..0000000
--- a/wpiutil/src/test/native/cpp/WebSocketServerTest.cpp
+++ /dev/null
@@ -1,736 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocket.h"  // NOLINT(build/include_order)
-
-#include "WebSocketTest.h"
-#include "wpi/Base64.h"
-#include "wpi/HttpParser.h"
-#include "wpi/SmallString.h"
-#include "wpi/raw_uv_ostream.h"
-#include "wpi/sha1.h"
-
-namespace wpi {
-
-class WebSocketServerTest : public WebSocketTest {
- public:
-  WebSocketServerTest() {
-    resp.headersComplete.connect([this](bool) { headersDone = true; });
-
-    serverPipe->Listen([this]() {
-      auto conn = serverPipe->Accept();
-      ws = WebSocket::CreateServer(*conn, "foo", "13");
-      if (setupWebSocket) {
-        setupWebSocket();
-      }
-    });
-    clientPipe->Connect(pipeName, [this]() {
-      clientPipe->StartRead();
-      clientPipe->data.connect([this](uv::Buffer& buf, size_t size) {
-        std::string_view data{buf.base, size};
-        if (!headersDone) {
-          data = resp.Execute(data);
-          if (resp.HasError()) {
-            Finish();
-          }
-          ASSERT_EQ(resp.GetError(), HPE_OK)
-              << http_errno_name(resp.GetError());
-          if (data.empty()) {
-            return;
-          }
-        }
-        wireData.insert(wireData.end(), data.begin(), data.end());
-        if (handleData) {
-          handleData(data);
-        }
-      });
-      clientPipe->end.connect([this]() { Finish(); });
-    });
-  }
-
-  std::function<void()> setupWebSocket;
-  std::function<void(std::string_view)> handleData;
-  std::vector<uint8_t> wireData;
-  std::shared_ptr<WebSocket> ws;
-  HttpParser resp{HttpParser::kResponse};
-  bool headersDone = false;
-};
-
-//
-// Terminate closes the endpoint but doesn't send a close frame.
-//
-
-TEST_F(WebSocketServerTest, Terminate) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Terminate(); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1006) << "reason: " << reason;
-    });
-  };
-
-  loop->Run();
-
-  ASSERT_TRUE(wireData.empty());  // terminate doesn't send data
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, TerminateCode) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Terminate(1000); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000) << "reason: " << reason;
-    });
-  };
-
-  loop->Run();
-
-  ASSERT_TRUE(wireData.empty());  // terminate doesn't send data
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, TerminateReason) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Terminate(1000, "reason"); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000);
-      ASSERT_EQ(reason, "reason");
-    });
-  };
-
-  loop->Run();
-
-  ASSERT_TRUE(wireData.empty());  // terminate doesn't send data
-  ASSERT_EQ(gotClosed, 1);
-}
-
-//
-// Close() sends a close frame.
-//
-
-TEST_F(WebSocketServerTest, CloseBasic) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Close(); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1005) << "reason: " << reason;
-    });
-  };
-  // need to respond with close for server to finish shutdown
-  auto message = BuildMessage(0x08, true, true, {});
-  handleData = [&](std::string_view) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x08, true, false, {});
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, CloseCode) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Close(1000); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000) << "reason: " << reason;
-    });
-  };
-  // need to respond with close for server to finish shutdown
-  const uint8_t contents[] = {0x03u, 0xe8u};
-  auto message = BuildMessage(0x08, true, true, contents);
-  handleData = [&](std::string_view) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x08, true, false, contents);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, CloseReason) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) { ws->Close(1000, "hangup"); });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000);
-      ASSERT_EQ(reason, "hangup");
-    });
-  };
-  // need to respond with close for server to finish shutdown
-  const uint8_t contents[] = {0x03u, 0xe8u, 'h', 'a', 'n', 'g', 'u', 'p'};
-  auto message = BuildMessage(0x08, true, true, contents);
-  handleData = [&](std::string_view) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x08, true, false, contents);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-//
-// Receiving a close frame results in closure and echoing the close frame.
-//
-
-TEST_F(WebSocketServerTest, ReceiveCloseBasic) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1005) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x08, true, true, {});
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  // the endpoint should echo the message
-  auto expectData = BuildMessage(0x08, true, false, {});
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, ReceiveCloseCode) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000) << "reason: " << reason;
-    });
-  };
-  const uint8_t contents[] = {0x03u, 0xe8u};
-  auto message = BuildMessage(0x08, true, true, contents);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  // the endpoint should echo the message
-  auto expectData = BuildMessage(0x08, true, false, contents);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketServerTest, ReceiveCloseReason) {
-  int gotClosed = 0;
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotClosed;
-      ASSERT_EQ(code, 1000);
-      ASSERT_EQ(reason, "hangup");
-    });
-  };
-  const uint8_t contents[] = {0x03u, 0xe8u, 'h', 'a', 'n', 'g', 'u', 'p'};
-  auto message = BuildMessage(0x08, true, true, contents);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  // the endpoint should echo the message
-  auto expectData = BuildMessage(0x08, true, false, contents);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotClosed, 1);
-}
-
-//
-// If an unknown opcode is received, the receiving endpoint MUST _Fail the
-// WebSocket Connection_.
-//
-
-class WebSocketServerBadOpcodeTest
-    : public WebSocketServerTest,
-      public ::testing::WithParamInterface<uint8_t> {};
-
-INSTANTIATE_TEST_SUITE_P(WebSocketServerBadOpcodeTests,
-                         WebSocketServerBadOpcodeTest,
-                         ::testing::Values(3, 4, 5, 6, 7, 0xb, 0xc, 0xd, 0xe,
-                                           0xf));
-
-TEST_P(WebSocketServerBadOpcodeTest, Receive) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(4, 0x03);
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(GetParam(), true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-//
-// Control frames themselves MUST NOT be fragmented.
-//
-
-class WebSocketServerControlFrameTest
-    : public WebSocketServerTest,
-      public ::testing::WithParamInterface<uint8_t> {};
-
-INSTANTIATE_TEST_SUITE_P(WebSocketServerControlFrameTests,
-                         WebSocketServerControlFrameTest,
-                         ::testing::Values(0x8, 0x9, 0xa));
-
-TEST_P(WebSocketServerControlFrameTest, ReceiveFragment) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(4, 0x03);
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(GetParam(), false, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-//
-// A fragmented message consists of a single frame with the FIN bit
-// clear and an opcode other than 0, followed by zero or more frames
-// with the FIN bit clear and the opcode set to 0, and terminated by
-// a single frame with the FIN bit set and an opcode of 0.
-//
-
-// No previous message
-TEST_F(WebSocketServerTest, ReceiveFragmentInvalidNoPrevFrame) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(4, 0x03);
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x00, false, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-// No previous message with FIN=1.
-TEST_F(WebSocketServerTest, ReceiveFragmentInvalidNoPrevFragment) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(4, 0x03);
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, true, true, {});  // FIN=1
-  auto message2 = BuildMessage(0x00, false, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}, {message2}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-// Incomplete fragment
-TEST_F(WebSocketServerTest, ReceiveFragmentInvalidIncomplete) {
-  int gotCallback = 0;
-  setupWebSocket = [&] {
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, false, true, {});
-  auto message2 = BuildMessage(0x00, false, true, {});
-  auto message3 = BuildMessage(0x01, true, true, {});
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}, {message2}, {message3}},
-                      [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-// Normally fragments are combined into a single callback
-TEST_F(WebSocketServerTest, ReceiveFragment) {
-  int gotCallback = 0;
-
-  std::vector<uint8_t> data(4, 0x03);
-  std::vector<uint8_t> data2(4, 0x04);
-  std::vector<uint8_t> data3(4, 0x05);
-  std::vector<uint8_t> combData{data};
-  combData.insert(combData.end(), data2.begin(), data2.end());
-  combData.insert(combData.end(), data3.begin(), data3.end());
-
-  setupWebSocket = [&] {
-    ws->binary.connect([&](auto inData, bool fin) {
-      ++gotCallback;
-      ws->Terminate();
-      ASSERT_TRUE(fin);
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      ASSERT_EQ(combData, recvData);
-    });
-  };
-
-  auto message = BuildMessage(0x02, false, true, data);
-  auto message2 = BuildMessage(0x00, false, true, data2);
-  auto message3 = BuildMessage(0x00, true, true, data3);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}, {message2}, {message3}},
-                      [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-// But can be configured for multiple callbacks
-TEST_F(WebSocketServerTest, ReceiveFragmentSeparate) {
-  int gotCallback = 0;
-
-  std::vector<uint8_t> data(4, 0x03);
-  std::vector<uint8_t> data2(4, 0x04);
-  std::vector<uint8_t> data3(4, 0x05);
-  std::vector<uint8_t> combData{data};
-  combData.insert(combData.end(), data2.begin(), data2.end());
-  combData.insert(combData.end(), data3.begin(), data3.end());
-
-  setupWebSocket = [&] {
-    ws->SetCombineFragments(false);
-    ws->binary.connect([&](auto inData, bool fin) {
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      switch (++gotCallback) {
-        case 1:
-          ASSERT_FALSE(fin);
-          ASSERT_EQ(data, recvData);
-          break;
-        case 2:
-          ASSERT_FALSE(fin);
-          ASSERT_EQ(data2, recvData);
-          break;
-        case 3:
-          ws->Terminate();
-          ASSERT_TRUE(fin);
-          ASSERT_EQ(data3, recvData);
-          break;
-        default:
-          FAIL() << "too many callbacks";
-          break;
-      }
-    });
-  };
-
-  auto message = BuildMessage(0x02, false, true, data);
-  auto message2 = BuildMessage(0x00, false, true, data2);
-  auto message3 = BuildMessage(0x00, true, true, data3);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}, {message2}, {message3}},
-                      [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 3);
-}
-
-//
-// Maximum message size is limited.
-//
-
-// Single message
-TEST_F(WebSocketServerTest, ReceiveTooLarge) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(2048, 0x03u);
-  setupWebSocket = [&] {
-    ws->SetMaxMessageSize(1024);
-    ws->binary.connect([&](auto, bool) {
-      ws->Terminate();
-      FAIL() << "Should not have gotten unmasked message";
-    });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1009) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-// Applied across fragments if combining
-TEST_F(WebSocketServerTest, ReceiveTooLargeFragmented) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(768, 0x03u);
-  setupWebSocket = [&] {
-    ws->SetMaxMessageSize(1024);
-    ws->binary.connect([&](auto, bool) {
-      ws->Terminate();
-      FAIL() << "Should not have gotten unmasked message";
-    });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1009) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, false, true, data);
-  auto message2 = BuildMessage(0x00, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}, {message2}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-//
-// Send and receive data.
-//
-
-class WebSocketServerDataTest : public WebSocketServerTest,
-                                public ::testing::WithParamInterface<size_t> {};
-
-INSTANTIATE_TEST_SUITE_P(WebSocketServerDataTests, WebSocketServerDataTest,
-                         ::testing::Values(0, 1, 125, 126, 65535, 65536));
-
-TEST_P(WebSocketServerDataTest, SendText) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), ' ');
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) {
-      ws->SendText({{data}}, [&](auto bufs, uv::Error) {
-        ++gotCallback;
-        ws->Terminate();
-        ASSERT_FALSE(bufs.empty());
-        ASSERT_EQ(bufs[0].base, reinterpret_cast<const char*>(data.data()));
-      });
-    });
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x01, true, false, data);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, SendBinary) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) {
-      ws->SendBinary({{data}}, [&](auto bufs, uv::Error) {
-        ++gotCallback;
-        ws->Terminate();
-        ASSERT_FALSE(bufs.empty());
-        ASSERT_EQ(bufs[0].base, reinterpret_cast<const char*>(data.data()));
-      });
-    });
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x02, true, false, data);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, SendPing) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) {
-      ws->SendPing({{data}}, [&](auto bufs, uv::Error) {
-        ++gotCallback;
-        ws->Terminate();
-        ASSERT_FALSE(bufs.empty());
-        ASSERT_EQ(bufs[0].base, reinterpret_cast<const char*>(data.data()));
-      });
-    });
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x09, true, false, data);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, SendPong) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->open.connect([&](std::string_view) {
-      ws->SendPong({{data}}, [&](auto bufs, uv::Error) {
-        ++gotCallback;
-        ws->Terminate();
-        ASSERT_FALSE(bufs.empty());
-        ASSERT_EQ(bufs[0].base, reinterpret_cast<const char*>(data.data()));
-      });
-    });
-  };
-
-  loop->Run();
-
-  auto expectData = BuildMessage(0x0a, true, false, data);
-  ASSERT_EQ(wireData, expectData);
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, ReceiveText) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), ' ');
-  setupWebSocket = [&] {
-    ws->text.connect([&](std::string_view inData, bool fin) {
-      ++gotCallback;
-      ws->Terminate();
-      ASSERT_TRUE(fin);
-      std::vector<uint8_t> recvData;
-      recvData.insert(recvData.end(), inData.begin(), inData.end());
-      ASSERT_EQ(data, recvData);
-    });
-  };
-  auto message = BuildMessage(0x01, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, ReceiveBinary) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->binary.connect([&](auto inData, bool fin) {
-      ++gotCallback;
-      ws->Terminate();
-      ASSERT_TRUE(fin);
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      ASSERT_EQ(data, recvData);
-    });
-  };
-  auto message = BuildMessage(0x02, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, ReceivePing) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->ping.connect([&](auto inData) {
-      ++gotCallback;
-      ws->Terminate();
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      ASSERT_EQ(data, recvData);
-    });
-  };
-  auto message = BuildMessage(0x09, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-TEST_P(WebSocketServerDataTest, ReceivePong) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), 0x03u);
-  setupWebSocket = [&] {
-    ws->pong.connect([&](auto inData) {
-      ++gotCallback;
-      ws->Terminate();
-      std::vector<uint8_t> recvData{inData.begin(), inData.end()};
-      ASSERT_EQ(data, recvData);
-    });
-  };
-  auto message = BuildMessage(0x0a, true, true, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-//
-// The server must close the connection if an unmasked frame is received.
-//
-
-TEST_P(WebSocketServerDataTest, ReceiveUnmasked) {
-  int gotCallback = 0;
-  std::vector<uint8_t> data(GetParam(), ' ');
-  setupWebSocket = [&] {
-    ws->text.connect([&](std::string_view, bool) {
-      ws->Terminate();
-      FAIL() << "Should not have gotten unmasked message";
-    });
-    ws->closed.connect([&](uint16_t code, std::string_view reason) {
-      ++gotCallback;
-      ASSERT_EQ(code, 1002) << "reason: " << reason;
-    });
-  };
-  auto message = BuildMessage(0x01, true, false, data);
-  resp.headersComplete.connect([&](bool) {
-    clientPipe->Write({{message}}, [&](auto bufs, uv::Error) {});
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(gotCallback, 1);
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/WebSocketTest.cpp b/wpiutil/src/test/native/cpp/WebSocketTest.cpp
deleted file mode 100644
index b5d5e4e..0000000
--- a/wpiutil/src/test/native/cpp/WebSocketTest.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WebSocket.h"  // NOLINT(build/include_order)
-
-#include "WebSocketTest.h"
-
-#include "wpi/HttpParser.h"
-#include "wpi/StringExtras.h"
-
-namespace wpi {
-
-#ifdef _WIN32
-const char* WebSocketTest::pipeName = "\\\\.\\pipe\\websocket-unit-test";
-#else
-const char* WebSocketTest::pipeName = "/tmp/websocket-unit-test";
-#endif
-const uint8_t WebSocketTest::testMask[4] = {0x11, 0x22, 0x33, 0x44};
-
-void WebSocketTest::SetUpTestCase() {
-#ifndef _WIN32
-  unlink(pipeName);
-#endif
-}
-
-std::vector<uint8_t> WebSocketTest::BuildHeader(uint8_t opcode, bool fin,
-                                                bool masking, uint64_t len) {
-  std::vector<uint8_t> data;
-  data.push_back(opcode | (fin ? 0x80u : 0x00u));
-  if (len < 126) {
-    data.push_back(len | (masking ? 0x80 : 0x00u));
-  } else if (len < 65536) {
-    data.push_back(126u | (masking ? 0x80 : 0x00u));
-    data.push_back(len >> 8);
-    data.push_back(len & 0xff);
-  } else {
-    data.push_back(127u | (masking ? 0x80u : 0x00u));
-    for (int i = 56; i >= 0; i -= 8) {
-      data.push_back((len >> i) & 0xff);
-    }
-  }
-  if (masking) {
-    data.insert(data.end(), &testMask[0], &testMask[4]);
-  }
-  return data;
-}
-
-std::vector<uint8_t> WebSocketTest::BuildMessage(uint8_t opcode, bool fin,
-                                                 bool masking,
-                                                 span<const uint8_t> data) {
-  auto finalData = BuildHeader(opcode, fin, masking, data.size());
-  size_t headerSize = finalData.size();
-  finalData.insert(finalData.end(), data.begin(), data.end());
-  if (masking) {
-    uint8_t mask[4] = {finalData[headerSize - 4], finalData[headerSize - 3],
-                       finalData[headerSize - 2], finalData[headerSize - 1]};
-    int n = 0;
-    for (size_t i = headerSize, end = finalData.size(); i < end; ++i) {
-      finalData[i] ^= mask[n++];
-      if (n >= 4) {
-        n = 0;
-      }
-    }
-  }
-  return finalData;
-}
-
-// If the message is masked, changes the mask to match the mask set by
-// BuildHeader() by unmasking and remasking.
-void WebSocketTest::AdjustMasking(span<uint8_t> message) {
-  if (message.size() < 2) {
-    return;
-  }
-  if ((message[1] & 0x80) == 0) {
-    return;  // not masked
-  }
-  size_t maskPos;
-  uint8_t len = message[1] & 0x7f;
-  if (len == 126) {
-    maskPos = 4;
-  } else if (len == 127) {
-    maskPos = 10;
-  } else {
-    maskPos = 2;
-  }
-  uint8_t mask[4] = {message[maskPos], message[maskPos + 1],
-                     message[maskPos + 2], message[maskPos + 3]};
-  message[maskPos] = testMask[0];
-  message[maskPos + 1] = testMask[1];
-  message[maskPos + 2] = testMask[2];
-  message[maskPos + 3] = testMask[3];
-  int n = 0;
-  for (auto& ch : message.subspan(maskPos + 4)) {
-    ch ^= mask[n] ^ testMask[n];
-    if (++n >= 4) {
-      n = 0;
-    }
-  }
-}
-
-TEST_F(WebSocketTest, CreateClientBasic) {
-  int gotHost = 0;
-  int gotUpgrade = 0;
-  int gotConnection = 0;
-  int gotKey = 0;
-  int gotVersion = 0;
-
-  HttpParser req{HttpParser::kRequest};
-  req.url.connect([](std::string_view url) { ASSERT_EQ(url, "/test"); });
-  req.header.connect([&](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "host")) {
-      ASSERT_EQ(value, pipeName);
-      ++gotHost;
-    } else if (equals_lower(name, "upgrade")) {
-      ASSERT_EQ(value, "websocket");
-      ++gotUpgrade;
-    } else if (equals_lower(name, "connection")) {
-      ASSERT_EQ(value, "Upgrade");
-      ++gotConnection;
-    } else if (equals_lower(name, "sec-websocket-key")) {
-      ++gotKey;
-    } else if (equals_lower(name, "sec-websocket-version")) {
-      ASSERT_EQ(value, "13");
-      ++gotVersion;
-    } else {
-      FAIL() << "unexpected header " << name;
-    }
-  });
-  req.headersComplete.connect([&](bool) { Finish(); });
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    conn->StartRead();
-    conn->data.connect([&](uv::Buffer& buf, size_t size) {
-      req.Execute(std::string_view{buf.base, size});
-      if (req.HasError()) {
-        Finish();
-      }
-      ASSERT_EQ(req.GetError(), HPE_OK) << http_errno_name(req.GetError());
-    });
-  });
-  clientPipe->Connect(pipeName, [&]() {
-    auto ws = WebSocket::CreateClient(*clientPipe, "/test", pipeName);
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotHost, 1);
-  ASSERT_EQ(gotUpgrade, 1);
-  ASSERT_EQ(gotConnection, 1);
-  ASSERT_EQ(gotKey, 1);
-  ASSERT_EQ(gotVersion, 1);
-}
-
-TEST_F(WebSocketTest, CreateClientExtraHeaders) {
-  int gotExtra1 = 0;
-  int gotExtra2 = 0;
-  HttpParser req{HttpParser::kRequest};
-  req.header.connect([&](std::string_view name, std::string_view value) {
-    if (equals(name, "Extra1")) {
-      ASSERT_EQ(value, "Data1");
-      ++gotExtra1;
-    } else if (equals(name, "Extra2")) {
-      ASSERT_EQ(value, "Data2");
-      ++gotExtra2;
-    }
-  });
-  req.headersComplete.connect([&](bool) { Finish(); });
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    conn->StartRead();
-    conn->data.connect([&](uv::Buffer& buf, size_t size) {
-      req.Execute(std::string_view{buf.base, size});
-      if (req.HasError()) {
-        Finish();
-      }
-      ASSERT_EQ(req.GetError(), HPE_OK) << http_errno_name(req.GetError());
-    });
-  });
-  clientPipe->Connect(pipeName, [&]() {
-    WebSocket::ClientOptions options;
-    SmallVector<std::pair<std::string_view, std::string_view>, 4> extraHeaders;
-    extraHeaders.emplace_back("Extra1", "Data1");
-    extraHeaders.emplace_back("Extra2", "Data2");
-    options.extraHeaders = extraHeaders;
-    auto ws =
-        WebSocket::CreateClient(*clientPipe, "/test", pipeName, {}, options);
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotExtra1, 1);
-  ASSERT_EQ(gotExtra2, 1);
-}
-
-TEST_F(WebSocketTest, CreateClientTimeout) {
-  int gotClosed = 0;
-  serverPipe->Listen([&]() { auto conn = serverPipe->Accept(); });
-  clientPipe->Connect(pipeName, [&]() {
-    WebSocket::ClientOptions options;
-    options.handshakeTimeout = uv::Timer::Time{100};
-    auto ws =
-        WebSocket::CreateClient(*clientPipe, "/test", pipeName, {}, options);
-    ws->closed.connect([&](uint16_t code, std::string_view) {
-      Finish();
-      ++gotClosed;
-      ASSERT_EQ(code, 1006);
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotClosed, 1);
-}
-
-TEST_F(WebSocketTest, CreateServerBasic) {
-  int gotStatus = 0;
-  int gotUpgrade = 0;
-  int gotConnection = 0;
-  int gotAccept = 0;
-  int gotOpen = 0;
-
-  HttpParser resp{HttpParser::kResponse};
-  resp.status.connect([&](std::string_view status) {
-    ++gotStatus;
-    ASSERT_EQ(resp.GetStatusCode(), 101u) << "status: " << status;
-  });
-  resp.header.connect([&](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "upgrade")) {
-      ASSERT_EQ(value, "websocket");
-      ++gotUpgrade;
-    } else if (equals_lower(name, "connection")) {
-      ASSERT_EQ(value, "Upgrade");
-      ++gotConnection;
-    } else if (equals_lower(name, "sec-websocket-accept")) {
-      ASSERT_EQ(value, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
-      ++gotAccept;
-    } else {
-      FAIL() << "unexpected header " << name;
-    }
-  });
-  resp.headersComplete.connect([&](bool) { Finish(); });
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto ws = WebSocket::CreateServer(*conn, "dGhlIHNhbXBsZSBub25jZQ==", "13");
-    ws->open.connect([&](std::string_view protocol) {
-      ++gotOpen;
-      ASSERT_TRUE(protocol.empty());
-    });
-  });
-  clientPipe->Connect(pipeName, [&] {
-    clientPipe->StartRead();
-    clientPipe->data.connect([&](uv::Buffer& buf, size_t size) {
-      resp.Execute(std::string_view{buf.base, size});
-      if (resp.HasError()) {
-        Finish();
-      }
-      ASSERT_EQ(resp.GetError(), HPE_OK) << http_errno_name(resp.GetError());
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotStatus, 1);
-  ASSERT_EQ(gotUpgrade, 1);
-  ASSERT_EQ(gotConnection, 1);
-  ASSERT_EQ(gotAccept, 1);
-  ASSERT_EQ(gotOpen, 1);
-}
-
-TEST_F(WebSocketTest, CreateServerProtocol) {
-  int gotProtocol = 0;
-  int gotOpen = 0;
-
-  HttpParser resp{HttpParser::kResponse};
-  resp.header.connect([&](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "sec-websocket-protocol")) {
-      ++gotProtocol;
-      ASSERT_EQ(value, "myProtocol");
-    }
-  });
-  resp.headersComplete.connect([&](bool) { Finish(); });
-
-  serverPipe->Listen([&]() {
-    auto conn = serverPipe->Accept();
-    auto ws = WebSocket::CreateServer(*conn, "foo", "13", "myProtocol");
-    ws->open.connect([&](std::string_view protocol) {
-      ++gotOpen;
-      ASSERT_EQ(protocol, "myProtocol");
-    });
-  });
-  clientPipe->Connect(pipeName, [&] {
-    clientPipe->StartRead();
-    clientPipe->data.connect([&](uv::Buffer& buf, size_t size) {
-      resp.Execute(std::string_view{buf.base, size});
-      if (resp.HasError()) {
-        Finish();
-      }
-      ASSERT_EQ(resp.GetError(), HPE_OK) << http_errno_name(resp.GetError());
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotProtocol, 1);
-  ASSERT_EQ(gotOpen, 1);
-}
-
-TEST_F(WebSocketTest, CreateServerBadVersion) {
-  int gotStatus = 0;
-  int gotVersion = 0;
-  int gotUpgrade = 0;
-
-  HttpParser resp{HttpParser::kResponse};
-  resp.status.connect([&](std::string_view status) {
-    ++gotStatus;
-    ASSERT_EQ(resp.GetStatusCode(), 426u) << "status: " << status;
-  });
-  resp.header.connect([&](std::string_view name, std::string_view value) {
-    if (equals_lower(name, "sec-websocket-version")) {
-      ++gotVersion;
-      ASSERT_EQ(value, "13");
-    } else if (equals_lower(name, "upgrade")) {
-      ++gotUpgrade;
-      ASSERT_EQ(value, "WebSocket");
-    } else {
-      FAIL() << "unexpected header " << name;
-    }
-  });
-  resp.headersComplete.connect([&](bool) { Finish(); });
-
-  serverPipe->Listen([&] {
-    auto conn = serverPipe->Accept();
-    auto ws = WebSocket::CreateServer(*conn, "foo", "14");
-    ws->open.connect([&](std::string_view) {
-      Finish();
-      FAIL();
-    });
-  });
-  clientPipe->Connect(pipeName, [&] {
-    clientPipe->StartRead();
-    clientPipe->data.connect([&](uv::Buffer& buf, size_t size) {
-      resp.Execute(std::string_view{buf.base, size});
-      if (resp.HasError()) {
-        Finish();
-      }
-      ASSERT_EQ(resp.GetError(), HPE_OK) << http_errno_name(resp.GetError());
-    });
-  });
-
-  loop->Run();
-
-  if (HasFatalFailure()) {
-    return;
-  }
-  ASSERT_EQ(gotStatus, 1);
-  ASSERT_EQ(gotVersion, 1);
-  ASSERT_EQ(gotUpgrade, 1);
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/WebSocketTest.h b/wpiutil/src/test/native/cpp/WebSocketTest.h
deleted file mode 100644
index fda4473..0000000
--- a/wpiutil/src/test/native/cpp/WebSocketTest.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#pragma once
-
-#include <cstdio>
-#include <memory>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "wpi/span.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Pipe.h"
-#include "wpi/uv/Timer.h"
-
-namespace wpi {
-
-class WebSocketTest : public ::testing::Test {
- public:
-  static const char* pipeName;
-
-  static void SetUpTestCase();
-
-  WebSocketTest() {
-    loop = uv::Loop::Create();
-    clientPipe = uv::Pipe::Create(loop);
-    serverPipe = uv::Pipe::Create(loop);
-
-    serverPipe->Bind(pipeName);
-
-#if 0
-    auto debugTimer = uv::Timer::Create(loop);
-    debugTimer->timeout.connect([this] {
-      std::printf("Active handles:\n");
-      uv_print_active_handles(loop->GetRaw(), stdout);
-    });
-    debugTimer->Start(uv::Timer::Time{100}, uv::Timer::Time{100});
-    debugTimer->Unreference();
-#endif
-
-    auto failTimer = uv::Timer::Create(loop);
-    failTimer->timeout.connect([this] {
-      loop->Stop();
-      FAIL() << "loop failed to terminate";
-    });
-    failTimer->Start(uv::Timer::Time{1000});
-    failTimer->Unreference();
-  }
-
-  ~WebSocketTest() override { Finish(); }
-
-  void Finish() {
-    loop->Walk([](uv::Handle& it) { it.Close(); });
-  }
-
-  static std::vector<uint8_t> BuildHeader(uint8_t opcode, bool fin,
-                                          bool masking, uint64_t len);
-  static std::vector<uint8_t> BuildMessage(uint8_t opcode, bool fin,
-                                           bool masking,
-                                           span<const uint8_t> data);
-  static void AdjustMasking(span<uint8_t> message);
-  static const uint8_t testMask[4];
-
-  std::shared_ptr<uv::Loop> loop;
-  std::shared_ptr<uv::Pipe> clientPipe;
-  std::shared_ptr<uv::Pipe> serverPipe;
-};
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/WorkerThreadTest.cpp b/wpiutil/src/test/native/cpp/WorkerThreadTest.cpp
deleted file mode 100644
index 9bc9a17..0000000
--- a/wpiutil/src/test/native/cpp/WorkerThreadTest.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/WorkerThread.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include <thread>
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi {
-
-TEST(WorkerThreadTest, Future) {
-  WorkerThread<int(bool)> worker;
-  future<int> f =
-      worker.QueueWork([](bool v) -> int { return v ? 1 : 2; }, true);
-  ASSERT_EQ(f.get(), 1);
-}
-
-TEST(WorkerThreadTest, FutureVoid) {
-  int callbacks = 0;
-  WorkerThread<void(int)> worker;
-  future<void> f = worker.QueueWork(
-      [&](int v) {
-        ++callbacks;
-        ASSERT_EQ(v, 3);
-      },
-      3);
-  f.get();
-  ASSERT_EQ(callbacks, 1);
-}
-
-TEST(WorkerThreadTest, Loop) {
-  int callbacks = 0;
-  WorkerThread<int(bool)> worker;
-  auto loop = uv::Loop::Create();
-  worker.SetLoop(*loop);
-  worker.QueueWorkThen([](bool v) -> int { return v ? 1 : 2; },
-                       [&](int v2) {
-                         ++callbacks;
-                         loop->Stop();
-                         ASSERT_EQ(v2, 1);
-                       },
-                       true);
-  auto f = worker.QueueWork([](bool) -> int { return 2; }, true);
-  ASSERT_EQ(f.get(), 2);
-  loop->Run();
-  ASSERT_EQ(callbacks, 1);
-}
-
-TEST(WorkerThreadTest, LoopVoid) {
-  int callbacks = 0;
-  WorkerThread<void(bool)> worker;
-  auto loop = uv::Loop::Create();
-  worker.SetLoop(*loop);
-  worker.QueueWorkThen([](bool) {},
-                       [&]() {
-                         ++callbacks;
-                         loop->Stop();
-                       },
-                       true);
-  auto f = worker.QueueWork([](bool) {}, true);
-  f.get();
-  loop->Run();
-  ASSERT_EQ(callbacks, 1);
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/hostname.cpp b/wpiutil/src/test/native/cpp/hostname.cpp
deleted file mode 100644
index 29cceb1..0000000
--- a/wpiutil/src/test/native/cpp/hostname.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/hostname.h"
-
-#include "gtest/gtest.h"
-#include "wpi/SmallString.h"
-#include "wpi/SmallVector.h"
-
-namespace wpi {
-TEST(HostNameTest, HostNameNotEmpty) {
-  ASSERT_NE(GetHostname(), "");
-}
-TEST(HostNameTest, HostNameNotEmptySmallVector) {
-  SmallVector<char, 256> name;
-  ASSERT_NE(GetHostname(name), "");
-}
-TEST(HostNameTest, HostNameEq) {
-  SmallVector<char, 256> nameBuf;
-  ASSERT_EQ(GetHostname(nameBuf), GetHostname());
-}
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/json/unit-cbor.cpp b/wpiutil/src/test/native/cpp/json/unit-cbor.cpp
index 2e37a17..dfb3b60 100644
--- a/wpiutil/src/test/native/cpp/json/unit-cbor.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-cbor.cpp
@@ -35,6 +35,9 @@
 #include "gtest/gtest.h"
 
 #include "unit-json.h"
+
+#include <cmath>
+
 using wpi::json;
 
 #include <fstream>
diff --git a/wpiutil/src/test/native/cpp/json/unit-constructor1.cpp b/wpiutil/src/test/native/cpp/json/unit-constructor1.cpp
index 85b9b91..273bfb6 100644
--- a/wpiutil/src/test/native/cpp/json/unit-constructor1.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-constructor1.cpp
@@ -35,6 +35,7 @@
 #include "gtest/gtest.h"
 
 #include <array>
+#include <cmath>
 #include <deque>
 #include <forward_list>
 #include <list>
diff --git a/wpiutil/src/test/native/cpp/json/unit-conversions.cpp b/wpiutil/src/test/native/cpp/json/unit-conversions.cpp
index b60e5ac..601055c 100644
--- a/wpiutil/src/test/native/cpp/json/unit-conversions.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-conversions.cpp
@@ -38,6 +38,7 @@
 using wpi::json;
 using wpi::JsonTest;
 
+#include <cmath>
 #include <deque>
 //#include <forward_list>
 #include <list>
diff --git a/wpiutil/src/test/native/cpp/json/unit-element_access2.cpp b/wpiutil/src/test/native/cpp/json/unit-element_access2.cpp
index 4b64123..ab953bd 100644
--- a/wpiutil/src/test/native/cpp/json/unit-element_access2.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-element_access2.cpp
@@ -35,6 +35,9 @@
 #include "gtest/gtest.h"
 
 #include "unit-json.h"
+
+#include <cmath>
+
 using wpi::json;
 
 class JsonElementObjectAccessTestBase {
diff --git a/wpiutil/src/test/native/cpp/json/unit-msgpack.cpp b/wpiutil/src/test/native/cpp/json/unit-msgpack.cpp
index c0a237d..73665ea 100644
--- a/wpiutil/src/test/native/cpp/json/unit-msgpack.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-msgpack.cpp
@@ -37,6 +37,7 @@
 #include "unit-json.h"
 using wpi::json;
 
+#include <cmath>
 #include <fstream>
 
 TEST(MessagePackDiscardedTest, Case)
diff --git a/wpiutil/src/test/native/cpp/json/unit-pointer_access.cpp b/wpiutil/src/test/native/cpp/json/unit-pointer_access.cpp
index a1a7fa4..3224b05 100644
--- a/wpiutil/src/test/native/cpp/json/unit-pointer_access.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-pointer_access.cpp
@@ -35,6 +35,9 @@
 #include "gtest/gtest.h"
 
 #include "unit-json.h"
+
+#include <cmath>
+
 using wpi::json;
 
 TEST(JsonPointerTest, TypesCreate)
diff --git a/wpiutil/src/test/native/cpp/json/unit-readme.cpp b/wpiutil/src/test/native/cpp/json/unit-readme.cpp
index 14d2b1b..d9bb9e5 100644
--- a/wpiutil/src/test/native/cpp/json/unit-readme.cpp
+++ b/wpiutil/src/test/native/cpp/json/unit-readme.cpp
@@ -200,7 +200,7 @@
 {
     std::vector<int> c_vector {1, 2, 3, 4};
     json j_vec(c_vector);
-    json j_vec2(wpi::span<const int>(c_vector.data(), c_vector.size()));
+    json j_vec2(std::span<const int>(c_vector.data(), c_vector.size()));
     // [1, 2, 3, 4]
 
     std::deque<float> c_deque {1.2f, 2.3f, 3.4f, 5.6f};
diff --git a/wpiutil/src/test/native/cpp/llvm/Chrono.cpp b/wpiutil/src/test/native/cpp/llvm/Chrono.cpp
new file mode 100644
index 0000000..5fe3e65
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/Chrono.cpp
@@ -0,0 +1,49 @@
+//===- llvm/unittest/Support/Chrono.cpp - Time utilities tests ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/Chrono.h"
+#include "wpi/SmallVector.h"
+#include "gtest/gtest.h"
+
+using namespace wpi;
+using namespace wpi::sys;
+using namespace std::chrono;
+
+namespace {
+
+TEST(Chrono, TimeTConversion) {
+  EXPECT_EQ(time_t(0), toTimeT(toTimePoint(time_t(0))));
+  EXPECT_EQ(time_t(1), toTimeT(toTimePoint(time_t(1))));
+  EXPECT_EQ(time_t(47), toTimeT(toTimePoint(time_t(47))));
+
+  TimePoint<> TP;
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+  TP += seconds(1);
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+  TP += hours(47);
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+}
+
+// Test that toTimePoint and toTimeT can be called with a arguments with varying
+// precisions.
+TEST(Chrono, ImplicitConversions) {
+  std::time_t TimeT = 47;
+  TimePoint<seconds> Sec = toTimePoint(TimeT);
+  TimePoint<milliseconds> Milli = toTimePoint(TimeT);
+  TimePoint<microseconds> Micro = toTimePoint(TimeT);
+  TimePoint<nanoseconds> Nano = toTimePoint(TimeT);
+  EXPECT_EQ(Sec, Milli);
+  EXPECT_EQ(Sec, Micro);
+  EXPECT_EQ(Sec, Nano);
+  EXPECT_EQ(TimeT, toTimeT(Sec));
+  EXPECT_EQ(TimeT, toTimeT(Milli));
+  EXPECT_EQ(TimeT, toTimeT(Micro));
+  EXPECT_EQ(TimeT, toTimeT(Nano));
+}
+
+} // anonymous namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/ConvertUTFTest.cpp b/wpiutil/src/test/native/cpp/llvm/ConvertUTFTest.cpp
new file mode 100644
index 0000000..762682e
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/ConvertUTFTest.cpp
@@ -0,0 +1,1712 @@
+//===- llvm/unittest/Support/ConvertUTFTest.cpp - ConvertUTF tests --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/ConvertUTF.h"
+#include "wpi/SmallString.h"
+#include "wpi/SmallVector.h"
+#include "gtest/gtest.h"
+#include <string>
+#include <vector>
+
+using namespace wpi;
+
+TEST(ConvertUTFTest, ConvertUTF16LittleEndianToUTF8String) {
+  // Src is the look of disapproval.
+  alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
+  std::span<const char> Ref(Src, sizeof(Src) - 1);
+  SmallString<20> Result;
+  bool Success = convertUTF16ToUTF8String(Ref, Result);
+  EXPECT_TRUE(Success);
+  std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
+  EXPECT_EQ(Expected, std::string{Result});
+}
+
+TEST(ConvertUTFTest, ConvertUTF16BigEndianToUTF8String) {
+  // Src is the look of disapproval.
+  alignas(UTF16) static const char Src[] = "\xfe\xff\x0c\xa0\x00_\x0c\xa0";
+  std::span<const char> Ref(Src, sizeof(Src) - 1);
+  SmallString<20> Result;
+  bool Success = convertUTF16ToUTF8String(Ref, Result);
+  EXPECT_TRUE(Success);
+  std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
+  EXPECT_EQ(Expected, std::string{Result});
+}
+
+TEST(ConvertUTFTest, ConvertUTF8ToUTF16String) {
+  // Src is the look of disapproval.
+  static const char Src[] = "\xe0\xb2\xa0_\xe0\xb2\xa0";
+  std::string_view Ref(Src, sizeof(Src) - 1);
+  SmallVector<UTF16, 5> Result;
+  bool Success = convertUTF8ToUTF16String(Ref, Result);
+  EXPECT_TRUE(Success);
+  static const UTF16 Expected[] = {0x0CA0, 0x005f, 0x0CA0, 0};
+  ASSERT_EQ(3u, Result.size());
+  for (int I = 0, E = 3; I != E; ++I)
+    EXPECT_EQ(Expected[I], Result[I]);
+}
+
+TEST(ConvertUTFTest, OddLengthInput) {
+  SmallString<20> Result;
+  bool Success = convertUTF16ToUTF8String(std::span<const char>("xxxxx", 5), Result);
+  EXPECT_FALSE(Success);
+}
+
+TEST(ConvertUTFTest, Empty) {
+  SmallString<20> Result;
+  bool Success = convertUTF16ToUTF8String(std::span<const char>(), Result);
+  EXPECT_TRUE(Success);
+  EXPECT_TRUE(std::string{Result}.empty());
+}
+
+TEST(ConvertUTFTest, HasUTF16BOM) {
+  bool HasBOM = hasUTF16ByteOrderMark("\xff\xfe");
+  EXPECT_TRUE(HasBOM);
+  HasBOM = hasUTF16ByteOrderMark("\xfe\xff");
+  EXPECT_TRUE(HasBOM);
+  HasBOM = hasUTF16ByteOrderMark("\xfe\xff ");
+  EXPECT_TRUE(HasBOM); // Don't care about odd lengths.
+  HasBOM = hasUTF16ByteOrderMark("\xfe\xff\x00asdf");
+  EXPECT_TRUE(HasBOM);
+
+  HasBOM = hasUTF16ByteOrderMark("");
+  EXPECT_FALSE(HasBOM);
+  HasBOM = hasUTF16ByteOrderMark("\xfe");
+  EXPECT_FALSE(HasBOM);
+}
+
+TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) {
+  // Src is the look of disapproval.
+  alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c";
+  std::span<const UTF16> SrcRef((const UTF16 *)Src, 4);
+  SmallString<20> Result;
+  bool Success = convertUTF16ToUTF8String(SrcRef, Result);
+  EXPECT_TRUE(Success);
+  std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
+  EXPECT_EQ(Expected, std::string{Result});
+}
+
+TEST(ConvertUTFTest, ConvertUTF8toWide) {
+  // Src is the look of disapproval.
+  static const char Src[] = "\xe0\xb2\xa0_\xe0\xb2\xa0";
+  std::wstring Result;
+  bool Success = ConvertUTF8toWide((const char*)Src, Result);
+  EXPECT_TRUE(Success);
+  std::wstring Expected(L"\x0ca0_\x0ca0");
+  EXPECT_EQ(Expected, Result);
+  Result.clear();
+  Success = ConvertUTF8toWide(Src, Result);
+  EXPECT_TRUE(Success);
+  EXPECT_EQ(Expected, Result);
+}
+
+TEST(ConvertUTFTest, convertWideToUTF8) {
+  // Src is the look of disapproval.
+  static const wchar_t Src[] = L"\x0ca0_\x0ca0";
+  SmallString<20> Result;
+  bool Success = convertWideToUTF8(Src, Result);
+  EXPECT_TRUE(Success);
+  std::string Expected("\xe0\xb2\xa0_\xe0\xb2\xa0");
+  EXPECT_EQ(Expected, std::string{Result});
+}
+
+struct ConvertUTFResultContainer {
+  ConversionResult ErrorCode;
+  std::vector<unsigned> UnicodeScalars;
+
+  ConvertUTFResultContainer(ConversionResult ErrorCode)
+      : ErrorCode(ErrorCode) {}
+
+  ConvertUTFResultContainer
+  withScalars(unsigned US0 = 0x110000, unsigned US1 = 0x110000,
+              unsigned US2 = 0x110000, unsigned US3 = 0x110000,
+              unsigned US4 = 0x110000, unsigned US5 = 0x110000,
+              unsigned US6 = 0x110000, unsigned US7 = 0x110000) {
+    ConvertUTFResultContainer Result(*this);
+    if (US0 != 0x110000)
+      Result.UnicodeScalars.push_back(US0);
+    if (US1 != 0x110000)
+      Result.UnicodeScalars.push_back(US1);
+    if (US2 != 0x110000)
+      Result.UnicodeScalars.push_back(US2);
+    if (US3 != 0x110000)
+      Result.UnicodeScalars.push_back(US3);
+    if (US4 != 0x110000)
+      Result.UnicodeScalars.push_back(US4);
+    if (US5 != 0x110000)
+      Result.UnicodeScalars.push_back(US5);
+    if (US6 != 0x110000)
+      Result.UnicodeScalars.push_back(US6);
+    if (US7 != 0x110000)
+      Result.UnicodeScalars.push_back(US7);
+    return Result;
+  }
+};
+
+std::pair<ConversionResult, std::vector<unsigned>>
+ConvertUTF8ToUnicodeScalarsLenient(std::string_view S) {
+  const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(S.data());
+
+  const UTF8 *SourceNext = SourceStart;
+  std::vector<UTF32> Decoded(S.size(), 0);
+  UTF32 *TargetStart = Decoded.data();
+
+  auto ErrorCode =
+      ConvertUTF8toUTF32(&SourceNext, SourceStart + S.size(), &TargetStart,
+                         Decoded.data() + Decoded.size(), lenientConversion);
+
+  Decoded.resize(TargetStart - Decoded.data());
+
+  return std::make_pair(ErrorCode, Decoded);
+}
+
+std::pair<ConversionResult, std::vector<unsigned>>
+ConvertUTF8ToUnicodeScalarsPartialLenient(std::string_view S) {
+  const UTF8 *SourceStart = reinterpret_cast<const UTF8 *>(S.data());
+
+  const UTF8 *SourceNext = SourceStart;
+  std::vector<UTF32> Decoded(S.size(), 0);
+  UTF32 *TargetStart = Decoded.data();
+
+  auto ErrorCode = ConvertUTF8toUTF32Partial(
+      &SourceNext, SourceStart + S.size(), &TargetStart,
+      Decoded.data() + Decoded.size(), lenientConversion);
+
+  Decoded.resize(TargetStart - Decoded.data());
+
+  return std::make_pair(ErrorCode, Decoded);
+}
+
+::testing::AssertionResult
+CheckConvertUTF8ToUnicodeScalars(ConvertUTFResultContainer Expected,
+                                 std::string_view S, bool Partial = false) {
+  ConversionResult ErrorCode;
+  std::vector<unsigned> Decoded;
+  if (!Partial)
+    std::tie(ErrorCode, Decoded) = ConvertUTF8ToUnicodeScalarsLenient(S);
+  else
+    std::tie(ErrorCode, Decoded) = ConvertUTF8ToUnicodeScalarsPartialLenient(S);
+
+  if (Expected.ErrorCode != ErrorCode)
+    return ::testing::AssertionFailure() << "Expected error code "
+                                         << Expected.ErrorCode << ", actual "
+                                         << ErrorCode;
+
+  if (Expected.UnicodeScalars != Decoded)
+    return ::testing::AssertionFailure()
+           << "Expected lenient decoded result:\n"
+           << ::testing::PrintToString(Expected.UnicodeScalars) << "\n"
+           << "Actual result:\n" << ::testing::PrintToString(Decoded);
+
+  return ::testing::AssertionSuccess();
+}
+
+TEST(ConvertUTFTest, UTF8ToUTF32Lenient) {
+
+  //
+  // 1-byte sequences
+  //
+
+  // U+0041 LATIN CAPITAL LETTER A
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0041), "\x41"));
+
+  //
+  // 2-byte sequences
+  //
+
+  // U+0283 LATIN SMALL LETTER ESH
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0283),
+      "\xca\x83"));
+
+  // U+03BA GREEK SMALL LETTER KAPPA
+  // U+1F79 GREEK SMALL LETTER OMICRON WITH OXIA
+  // U+03C3 GREEK SMALL LETTER SIGMA
+  // U+03BC GREEK SMALL LETTER MU
+  // U+03B5 GREEK SMALL LETTER EPSILON
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK)
+          .withScalars(0x03ba, 0x1f79, 0x03c3, 0x03bc, 0x03b5),
+      "\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5"));
+
+  //
+  // 3-byte sequences
+  //
+
+  // U+4F8B CJK UNIFIED IDEOGRAPH-4F8B
+  // U+6587 CJK UNIFIED IDEOGRAPH-6587
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x4f8b, 0x6587),
+      "\xe4\xbe\x8b\xe6\x96\x87"));
+
+  // U+D55C HANGUL SYLLABLE HAN
+  // U+AE00 HANGUL SYLLABLE GEUL
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xd55c, 0xae00),
+      "\xed\x95\x9c\xea\xb8\x80"));
+
+  // U+1112 HANGUL CHOSEONG HIEUH
+  // U+1161 HANGUL JUNGSEONG A
+  // U+11AB HANGUL JONGSEONG NIEUN
+  // U+1100 HANGUL CHOSEONG KIYEOK
+  // U+1173 HANGUL JUNGSEONG EU
+  // U+11AF HANGUL JONGSEONG RIEUL
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK)
+          .withScalars(0x1112, 0x1161, 0x11ab, 0x1100, 0x1173, 0x11af),
+      "\xe1\x84\x92\xe1\x85\xa1\xe1\x86\xab\xe1\x84\x80\xe1\x85\xb3"
+      "\xe1\x86\xaf"));
+
+  //
+  // 4-byte sequences
+  //
+
+  // U+E0100 VARIATION SELECTOR-17
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x000E0100),
+      "\xf3\xa0\x84\x80"));
+
+  //
+  // First possible sequence of a certain length
+  //
+
+  // U+0000 NULL
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
+      std::string_view("\x00", 1)));
+
+  // U+0080 PADDING CHARACTER
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0080),
+      "\xc2\x80"));
+
+  // U+0800 SAMARITAN LETTER ALAF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0800),
+      "\xe0\xa0\x80"));
+
+  // U+10000 LINEAR B SYLLABLE B008 A
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x10000),
+      "\xf0\x90\x80\x80"));
+
+  // U+200000 (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x88\x80\x80\x80"));
+
+  // U+4000000 (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x84\x80\x80\x80\x80"));
+
+  //
+  // Last possible sequence of a certain length
+  //
+
+  // U+007F DELETE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x007f), "\x7f"));
+
+  // U+07FF (unassigned)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x07ff),
+      "\xdf\xbf"));
+
+  // U+FFFF (noncharacter)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xffff),
+      "\xef\xbf\xbf"));
+
+  // U+1FFFFF (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf7\xbf\xbf\xbf"));
+
+  // U+3FFFFFF (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfb\xbf\xbf\xbf\xbf"));
+
+  // U+7FFFFFFF (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfd\xbf\xbf\xbf\xbf\xbf"));
+
+  //
+  // Other boundary conditions
+  //
+
+  // U+D7FF (unassigned)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xd7ff),
+      "\xed\x9f\xbf"));
+
+  // U+E000 (private use)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xe000),
+      "\xee\x80\x80"));
+
+  // U+FFFD REPLACEMENT CHARACTER
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfffd),
+      "\xef\xbf\xbd"));
+
+  // U+10FFFF (noncharacter)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x10ffff),
+      "\xf4\x8f\xbf\xbf"));
+
+  // U+110000 (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf4\x90\x80\x80"));
+
+  //
+  // Unexpected continuation bytes
+  //
+
+  // A sequence of unexpected continuation bytes that don't follow a first
+  // byte, every byte is a maximal subpart.
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\x80\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xbf\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\x80\xbf\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\x80\xbf\x80\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\x80\xbf\x82\xbf\xaa"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xaa\xb0\xbb\xbf\xaa\xa0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xaa\xb0\xbb\xbf\xaa\xa0\x8f"));
+
+  // All continuation bytes (0x80--0xbf).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+      "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
+      "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
+      "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"));
+
+  //
+  // Lonely start bytes
+  //
+
+  // Start bytes of 2-byte sequences (0xc0--0xdf).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"
+      "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xc0\x20\xc1\x20\xc2\x20\xc3\x20\xc4\x20\xc5\x20\xc6\x20\xc7\x20"
+      "\xc8\x20\xc9\x20\xca\x20\xcb\x20\xcc\x20\xcd\x20\xce\x20\xcf\x20"
+      "\xd0\x20\xd1\x20\xd2\x20\xd3\x20\xd4\x20\xd5\x20\xd6\x20\xd7\x20"
+      "\xd8\x20\xd9\x20\xda\x20\xdb\x20\xdc\x20\xdd\x20\xde\x20\xdf\x20"));
+
+  // Start bytes of 3-byte sequences (0xe0--0xef).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xe0\x20\xe1\x20\xe2\x20\xe3\x20\xe4\x20\xe5\x20\xe6\x20\xe7\x20"
+      "\xe8\x20\xe9\x20\xea\x20\xeb\x20\xec\x20\xed\x20\xee\x20\xef\x20"));
+
+  // Start bytes of 4-byte sequences (0xf0--0xf7).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd,
+                       0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xf0\x20\xf1\x20\xf2\x20\xf3\x20\xf4\x20\xf5\x20\xf6\x20\xf7\x20"));
+
+  // Start bytes of 5-byte sequences (0xf8--0xfb).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\xf9\xfa\xfb"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xf8\x20\xf9\x20\xfa\x20\xfb\x20"));
+
+  // Start bytes of 6-byte sequences (0xfc--0xfd).
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfc\xfd"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xfc\x20\xfd\x20"));
+
+  //
+  // Other bytes (0xc0--0xc1, 0xfe--0xff).
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc1"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfe"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xff"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xc0\xc1\xfe\xff"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfe\xfe\xff\xff"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfe\x80\x80\x80\x80\x80"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xff\x80\x80\x80\x80\x80"));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0x0020, 0xfffd, 0x0020,
+                       0xfffd, 0x0020, 0xfffd, 0x0020),
+      "\xc0\x20\xc1\x20\xfe\x20\xff\x20"));
+
+  //
+  // Sequences with one continuation byte missing
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xc2"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xdf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xe0\xa0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xe0\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xe1\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xec\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xed\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xed\x9f"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xee\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xef\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf0\x90\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf0\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf1\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf3\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf4\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf4\x8f\xbf"));
+
+  // Overlong sequences with one trailing byte missing.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xc0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xc1"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xe0\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xe0\x9f"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x8f\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x80\x80\x80\x80"));
+
+  // Sequences that represent surrogates with one trailing byte missing.
+  // High surrogates
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xa0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xac"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xaf"));
+  // Low surrogates
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xb0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xb4"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xed\xbf"));
+
+  // Ill-formed 4-byte sequences.
+  // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+1100xx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf4\x90\x80"));
+  // U+13FBxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf4\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf5\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf6\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf7\x80\x80"));
+  // U+1FFBxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf7\xbf\xbf"));
+
+  // Ill-formed 5-byte sequences.
+  // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+2000xx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x88\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\xbf\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf9\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfa\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfb\x80\x80\x80"));
+  // U+3FFFFxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfb\xbf\xbf\xbf"));
+
+  // Ill-formed 6-byte sequences.
+  // 1111110u 10uuuuuu 10uzzzzz 10zzzyyyy 10yyyyxx 10xxxxxx
+  // U+40000xx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x84\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\xbf\xbf\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfd\x80\x80\x80\x80"));
+  // U+7FFFFFxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfd\xbf\xbf\xbf\xbf"));
+
+  //
+  // Sequences with two continuation bytes missing
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf0\x90"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf0\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf1\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf3\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf4\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd),
+      "\xf4\x8f"));
+
+  // Overlong sequences with two trailing byte missing.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xe0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf0\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf0\x8f"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x80\x80\x80"));
+
+  // Sequences that represent surrogates with two trailing bytes missing.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xed"));
+
+  // Ill-formed 4-byte sequences.
+  // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+110yxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf4\x90"));
+  // U+13Fyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf4\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf5\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf6\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf7\x80"));
+  // U+1FFyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf7\xbf"));
+
+  // Ill-formed 5-byte sequences.
+  // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+200yxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x88\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf8\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xf9\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfa\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfb\x80\x80"));
+  // U+3FFFyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfb\xbf\xbf"));
+
+  // Ill-formed 6-byte sequences.
+  // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+4000yxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x84\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\xbf\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfd\x80\x80\x80"));
+  // U+7FFFFyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfd\xbf\xbf\xbf"));
+
+  //
+  // Sequences with three continuation bytes missing
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf1"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf2"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf3"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf4"));
+
+  // Broken overlong sequences.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf0"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf8\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x80\x80"));
+
+  // Ill-formed 4-byte sequences.
+  // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+14yyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf5"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf6"));
+  // U+1Cyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf7"));
+
+  // Ill-formed 5-byte sequences.
+  // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+20yyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf8\x88"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf8\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xf9\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfa\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfb\x80"));
+  // U+3FCyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfb\xbf"));
+
+  // Ill-formed 6-byte sequences.
+  // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+400yyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x84\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfc\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfd\x80\x80"));
+  // U+7FFCyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xfd\xbf\xbf"));
+
+  //
+  // Sequences with four continuation bytes missing
+  //
+
+  // Ill-formed 5-byte sequences.
+  // 111110uu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+uzyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf8"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf9"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfa"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfb"));
+  // U+3zyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfb"));
+
+  // Broken overlong sequences.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xf8"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfc\x80"));
+
+  // Ill-formed 6-byte sequences.
+  // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+uzzyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfc\x84"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfc\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfd\x80"));
+  // U+7Fzzyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xfd\xbf"));
+
+  //
+  // Sequences with five continuation bytes missing
+  //
+
+  // Ill-formed 6-byte sequences.
+  // 1111110u 10uuuuuu 10zzzzzz 10zzyyyy 10yyyyxx 10xxxxxx
+  // U+uzzyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfc"));
+  // U+uuzzyyxx (invalid)
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd), "\xfd"));
+
+  //
+  // Consecutive sequences with trailing bytes missing
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, /**/ 0xfffd, 0xfffd, /**/ 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, /**/ 0xfffd, /**/ 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xc0" "\xe0\x80" "\xf0\x80\x80"
+      "\xf8\x80\x80\x80"
+      "\xfc\x80\x80\x80\x80"
+      "\xdf" "\xef\xbf" "\xf7\xbf\xbf"
+      "\xfb\xbf\xbf\xbf"
+      "\xfd\xbf\xbf\xbf\xbf"));
+
+  //
+  // Overlong UTF-8 sequences
+  //
+
+  // U+002F SOLIDUS
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x002f), "\x2f"));
+
+  // Overlong sequences of the above.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xc0\xaf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xe0\x80\xaf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x80\x80\xaf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x80\x80\x80\xaf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x80\x80\x80\x80\xaf"));
+
+  // U+0000 NULL
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0000),
+      std::string_view("\x00", 1)));
+
+  // Overlong sequences of the above.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xc0\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xe0\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x80\x80\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x80\x80\x80\x80\x80"));
+
+  // Other overlong sequences.
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xc0\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xc1\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal).withScalars(0xfffd, 0xfffd),
+      "\xc1\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xe0\x9f\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xa0\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x8f\x80\x80"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf0\x8f\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xf8\x87\xbf\xbf\xbf"));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xfc\x83\xbf\xbf\xbf\xbf"));
+
+  //
+  // Isolated surrogates
+  //
+
+  // Unicode 6.3.0:
+  //
+  //    D71.  High-surrogate code point: A Unicode code point in the range
+  //    U+D800 to U+DBFF.
+  //
+  //    D73.  Low-surrogate code point: A Unicode code point in the range
+  //    U+DC00 to U+DFFF.
+
+  // Note: U+E0100 is <DB40 DD00> in UTF16.
+
+  // High surrogates
+
+  // U+D800
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xa0\x80"));
+
+  // U+DB40
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xac\xa0"));
+
+  // U+DBFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xaf\xbf"));
+
+  // Low surrogates
+
+  // U+DC00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xb0\x80"));
+
+  // U+DD00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xb4\x80"));
+
+  // U+DFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd),
+      "\xed\xbf\xbf"));
+
+  // Surrogate pairs
+
+  // U+D800 U+DC00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xa0\x80\xed\xb0\x80"));
+
+  // U+D800 U+DD00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xa0\x80\xed\xb4\x80"));
+
+  // U+D800 U+DFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xa0\x80\xed\xbf\xbf"));
+
+  // U+DB40 U+DC00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xac\xa0\xed\xb0\x80"));
+
+  // U+DB40 U+DD00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xac\xa0\xed\xb4\x80"));
+
+  // U+DB40 U+DFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xac\xa0\xed\xbf\xbf"));
+
+  // U+DBFF U+DC00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xaf\xbf\xed\xb0\x80"));
+
+  // U+DBFF U+DD00
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xaf\xbf\xed\xb4\x80"));
+
+  // U+DBFF U+DFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceIllegal)
+          .withScalars(0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd),
+      "\xed\xaf\xbf\xed\xbf\xbf"));
+
+  //
+  // Noncharacters
+  //
+
+  // Unicode 6.3.0:
+  //
+  //    D14.  Noncharacter: A code point that is permanently reserved for
+  //    internal use and that should never be interchanged. Noncharacters
+  //    consist of the values U+nFFFE and U+nFFFF (where n is from 0 to 1016)
+  //    and the values U+FDD0..U+FDEF.
+
+  // U+FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfffe),
+      "\xef\xbf\xbe"));
+
+  // U+FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xffff),
+      "\xef\xbf\xbf"));
+
+  // U+1FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x1fffe),
+      "\xf0\x9f\xbf\xbe"));
+
+  // U+1FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x1ffff),
+      "\xf0\x9f\xbf\xbf"));
+
+  // U+2FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x2fffe),
+      "\xf0\xaf\xbf\xbe"));
+
+  // U+2FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x2ffff),
+      "\xf0\xaf\xbf\xbf"));
+
+  // U+3FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x3fffe),
+      "\xf0\xbf\xbf\xbe"));
+
+  // U+3FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x3ffff),
+      "\xf0\xbf\xbf\xbf"));
+
+  // U+4FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x4fffe),
+      "\xf1\x8f\xbf\xbe"));
+
+  // U+4FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x4ffff),
+      "\xf1\x8f\xbf\xbf"));
+
+  // U+5FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x5fffe),
+      "\xf1\x9f\xbf\xbe"));
+
+  // U+5FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x5ffff),
+      "\xf1\x9f\xbf\xbf"));
+
+  // U+6FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x6fffe),
+      "\xf1\xaf\xbf\xbe"));
+
+  // U+6FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x6ffff),
+      "\xf1\xaf\xbf\xbf"));
+
+  // U+7FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x7fffe),
+      "\xf1\xbf\xbf\xbe"));
+
+  // U+7FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x7ffff),
+      "\xf1\xbf\xbf\xbf"));
+
+  // U+8FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x8fffe),
+      "\xf2\x8f\xbf\xbe"));
+
+  // U+8FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x8ffff),
+      "\xf2\x8f\xbf\xbf"));
+
+  // U+9FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x9fffe),
+      "\xf2\x9f\xbf\xbe"));
+
+  // U+9FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x9ffff),
+      "\xf2\x9f\xbf\xbf"));
+
+  // U+AFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xafffe),
+      "\xf2\xaf\xbf\xbe"));
+
+  // U+AFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xaffff),
+      "\xf2\xaf\xbf\xbf"));
+
+  // U+BFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xbfffe),
+      "\xf2\xbf\xbf\xbe"));
+
+  // U+BFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xbffff),
+      "\xf2\xbf\xbf\xbf"));
+
+  // U+CFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xcfffe),
+      "\xf3\x8f\xbf\xbe"));
+
+  // U+CFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xcfffF),
+      "\xf3\x8f\xbf\xbf"));
+
+  // U+DFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xdfffe),
+      "\xf3\x9f\xbf\xbe"));
+
+  // U+DFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xdffff),
+      "\xf3\x9f\xbf\xbf"));
+
+  // U+EFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xefffe),
+      "\xf3\xaf\xbf\xbe"));
+
+  // U+EFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xeffff),
+      "\xf3\xaf\xbf\xbf"));
+
+  // U+FFFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xffffe),
+      "\xf3\xbf\xbf\xbe"));
+
+  // U+FFFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfffff),
+      "\xf3\xbf\xbf\xbf"));
+
+  // U+10FFFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x10fffe),
+      "\xf4\x8f\xbf\xbe"));
+
+  // U+10FFFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x10ffff),
+      "\xf4\x8f\xbf\xbf"));
+
+  // U+FDD0
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd0),
+      "\xef\xb7\x90"));
+
+  // U+FDD1
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd1),
+      "\xef\xb7\x91"));
+
+  // U+FDD2
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd2),
+      "\xef\xb7\x92"));
+
+  // U+FDD3
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd3),
+      "\xef\xb7\x93"));
+
+  // U+FDD4
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd4),
+      "\xef\xb7\x94"));
+
+  // U+FDD5
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd5),
+      "\xef\xb7\x95"));
+
+  // U+FDD6
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd6),
+      "\xef\xb7\x96"));
+
+  // U+FDD7
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd7),
+      "\xef\xb7\x97"));
+
+  // U+FDD8
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd8),
+      "\xef\xb7\x98"));
+
+  // U+FDD9
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdd9),
+      "\xef\xb7\x99"));
+
+  // U+FDDA
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdda),
+      "\xef\xb7\x9a"));
+
+  // U+FDDB
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfddb),
+      "\xef\xb7\x9b"));
+
+  // U+FDDC
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfddc),
+      "\xef\xb7\x9c"));
+
+  // U+FDDD
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfddd),
+      "\xef\xb7\x9d"));
+
+  // U+FDDE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdde),
+      "\xef\xb7\x9e"));
+
+  // U+FDDF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfddf),
+      "\xef\xb7\x9f"));
+
+  // U+FDE0
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde0),
+      "\xef\xb7\xa0"));
+
+  // U+FDE1
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde1),
+      "\xef\xb7\xa1"));
+
+  // U+FDE2
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde2),
+      "\xef\xb7\xa2"));
+
+  // U+FDE3
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde3),
+      "\xef\xb7\xa3"));
+
+  // U+FDE4
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde4),
+      "\xef\xb7\xa4"));
+
+  // U+FDE5
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde5),
+      "\xef\xb7\xa5"));
+
+  // U+FDE6
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde6),
+      "\xef\xb7\xa6"));
+
+  // U+FDE7
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde7),
+      "\xef\xb7\xa7"));
+
+  // U+FDE8
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde8),
+      "\xef\xb7\xa8"));
+
+  // U+FDE9
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfde9),
+      "\xef\xb7\xa9"));
+
+  // U+FDEA
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdea),
+      "\xef\xb7\xaa"));
+
+  // U+FDEB
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdeb),
+      "\xef\xb7\xab"));
+
+  // U+FDEC
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdec),
+      "\xef\xb7\xac"));
+
+  // U+FDED
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfded),
+      "\xef\xb7\xad"));
+
+  // U+FDEE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdee),
+      "\xef\xb7\xae"));
+
+  // U+FDEF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdef),
+      "\xef\xb7\xaf"));
+
+  // U+FDF0
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf0),
+      "\xef\xb7\xb0"));
+
+  // U+FDF1
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf1),
+      "\xef\xb7\xb1"));
+
+  // U+FDF2
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf2),
+      "\xef\xb7\xb2"));
+
+  // U+FDF3
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf3),
+      "\xef\xb7\xb3"));
+
+  // U+FDF4
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf4),
+      "\xef\xb7\xb4"));
+
+  // U+FDF5
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf5),
+      "\xef\xb7\xb5"));
+
+  // U+FDF6
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf6),
+      "\xef\xb7\xb6"));
+
+  // U+FDF7
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf7),
+      "\xef\xb7\xb7"));
+
+  // U+FDF8
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf8),
+      "\xef\xb7\xb8"));
+
+  // U+FDF9
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdf9),
+      "\xef\xb7\xb9"));
+
+  // U+FDFA
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdfa),
+      "\xef\xb7\xba"));
+
+  // U+FDFB
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdfb),
+      "\xef\xb7\xbb"));
+
+  // U+FDFC
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdfc),
+      "\xef\xb7\xbc"));
+
+  // U+FDFD
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdfd),
+      "\xef\xb7\xbd"));
+
+  // U+FDFE
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdfe),
+      "\xef\xb7\xbe"));
+
+  // U+FDFF
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0xfdff),
+      "\xef\xb7\xbf"));
+}
+
+TEST(ConvertUTFTest, UTF8ToUTF32PartialLenient) {
+  // U+0041 LATIN CAPITAL LETTER A
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(conversionOK).withScalars(0x0041),
+      "\x41", true));
+
+  //
+  // Sequences with one continuation byte missing
+  //
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xc2", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xdf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xe0\xa0", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xe0\xbf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xe1\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xec\xbf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xed\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xed\x9f", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xee\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xef\xbf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf0\x90\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf0\xbf\xbf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf1\x80\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf3\xbf\xbf", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf4\x80\x80", true));
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted),
+      "\xf4\x8f\xbf", true));
+
+  EXPECT_TRUE(CheckConvertUTF8ToUnicodeScalars(
+      ConvertUTFResultContainer(sourceExhausted).withScalars(0x0041),
+      "\x41\xc2", true));
+}
+
diff --git a/wpiutil/src/test/native/cpp/llvm/DenseMapTest.cpp b/wpiutil/src/test/native/cpp/llvm/DenseMapTest.cpp
new file mode 100644
index 0000000..68c37c0
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/DenseMapTest.cpp
@@ -0,0 +1,680 @@
+//===- llvm/unittest/ADT/DenseMapMap.cpp - DenseMap unit tests --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+#include "wpi/DenseMap.h"
+#include "gtest/gtest.h"
+#include <map>
+#include <set>
+
+using namespace wpi;
+
+namespace {
+
+uint32_t getTestKey(int i, uint32_t *) { return i; }
+uint32_t getTestValue(int i, uint32_t *) { return 42 + i; }
+
+uint32_t *getTestKey(int i, uint32_t **) {
+  static uint32_t dummy_arr1[8192];
+  assert(i < 8192 && "Only support 8192 dummy keys.");
+  return &dummy_arr1[i];
+}
+uint32_t *getTestValue(int i, uint32_t **) {
+  static uint32_t dummy_arr1[8192];
+  assert(i < 8192 && "Only support 8192 dummy keys.");
+  return &dummy_arr1[i];
+}
+
+/// A test class that tries to check that construction and destruction
+/// occur correctly.
+class CtorTester {
+  static std::set<CtorTester *> Constructed;
+  int Value;
+
+public:
+  explicit CtorTester(int Value = 0) : Value(Value) {
+    EXPECT_TRUE(Constructed.insert(this).second);
+  }
+  CtorTester(uint32_t Value) : Value(Value) {
+    EXPECT_TRUE(Constructed.insert(this).second);
+  }
+  CtorTester(const CtorTester &Arg) : Value(Arg.Value) {
+    EXPECT_TRUE(Constructed.insert(this).second);
+  }
+  CtorTester &operator=(const CtorTester &) = default;
+  ~CtorTester() {
+    EXPECT_EQ(1u, Constructed.erase(this));
+  }
+  operator uint32_t() const { return Value; }
+
+  int getValue() const { return Value; }
+  bool operator==(const CtorTester &RHS) const { return Value == RHS.Value; }
+};
+
+std::set<CtorTester *> CtorTester::Constructed;
+
+struct CtorTesterMapInfo {
+  static inline CtorTester getEmptyKey() { return CtorTester(-1); }
+  static inline CtorTester getTombstoneKey() { return CtorTester(-2); }
+  static unsigned getHashValue(const CtorTester &Val) {
+    return Val.getValue() * 37u;
+  }
+  static bool isEqual(const CtorTester &LHS, const CtorTester &RHS) {
+    return LHS == RHS;
+  }
+};
+
+CtorTester getTestKey(int i, CtorTester *) { return CtorTester(i); }
+CtorTester getTestValue(int i, CtorTester *) { return CtorTester(42 + i); }
+
+// Test fixture, with helper functions implemented by forwarding to global
+// function overloads selected by component types of the type parameter. This
+// allows all of the map implementations to be tested with shared
+// implementations of helper routines.
+template <typename T>
+class DenseMapTest : public ::testing::Test {
+protected:
+  T Map;
+
+  static typename T::key_type *const dummy_key_ptr;
+  static typename T::mapped_type *const dummy_value_ptr;
+
+  typename T::key_type getKey(int i = 0) {
+    return getTestKey(i, dummy_key_ptr);
+  }
+  typename T::mapped_type getValue(int i = 0) {
+    return getTestValue(i, dummy_value_ptr);
+  }
+};
+
+template <typename T>
+typename T::key_type *const DenseMapTest<T>::dummy_key_ptr = nullptr;
+template <typename T>
+typename T::mapped_type *const DenseMapTest<T>::dummy_value_ptr = nullptr;
+
+// Register these types for testing.
+typedef ::testing::Types<DenseMap<uint32_t, uint32_t>,
+                         DenseMap<uint32_t *, uint32_t *>,
+                         DenseMap<CtorTester, CtorTester, CtorTesterMapInfo>,
+                         SmallDenseMap<uint32_t, uint32_t>,
+                         SmallDenseMap<uint32_t *, uint32_t *>,
+                         SmallDenseMap<CtorTester, CtorTester, 4,
+                                       CtorTesterMapInfo>
+                         > DenseMapTestTypes;
+TYPED_TEST_SUITE(DenseMapTest, DenseMapTestTypes, );
+
+// Empty map tests
+TYPED_TEST(DenseMapTest, EmptyIntMapTest) {
+  // Size tests
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+
+  // Iterator tests
+  EXPECT_TRUE(this->Map.begin() == this->Map.end());
+
+  // Lookup tests
+  EXPECT_FALSE(this->Map.count(this->getKey()));
+  EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.end());
+  EXPECT_EQ(typename TypeParam::mapped_type(),
+            this->Map.lookup(this->getKey()));
+}
+
+// Constant map tests
+TYPED_TEST(DenseMapTest, ConstEmptyMapTest) {
+  const TypeParam &ConstMap = this->Map;
+  EXPECT_EQ(0u, ConstMap.size());
+  EXPECT_TRUE(ConstMap.empty());
+  EXPECT_TRUE(ConstMap.begin() == ConstMap.end());
+}
+
+// A map with a single entry
+TYPED_TEST(DenseMapTest, SingleEntryMapTest) {
+  this->Map[this->getKey()] = this->getValue();
+
+  // Size tests
+  EXPECT_EQ(1u, this->Map.size());
+  EXPECT_FALSE(this->Map.begin() == this->Map.end());
+  EXPECT_FALSE(this->Map.empty());
+
+  // Iterator tests
+  typename TypeParam::iterator it = this->Map.begin();
+  EXPECT_EQ(this->getKey(), it->first);
+  EXPECT_EQ(this->getValue(), it->second);
+  ++it;
+  EXPECT_TRUE(it == this->Map.end());
+
+  // Lookup tests
+  EXPECT_TRUE(this->Map.count(this->getKey()));
+  EXPECT_TRUE(this->Map.find(this->getKey()) == this->Map.begin());
+  EXPECT_EQ(this->getValue(), this->Map.lookup(this->getKey()));
+  EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
+}
+
+// Test clear() method
+TYPED_TEST(DenseMapTest, ClearTest) {
+  this->Map[this->getKey()] = this->getValue();
+  this->Map.clear();
+
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+  EXPECT_TRUE(this->Map.begin() == this->Map.end());
+}
+
+// Test erase(iterator) method
+TYPED_TEST(DenseMapTest, EraseTest) {
+  this->Map[this->getKey()] = this->getValue();
+  this->Map.erase(this->Map.begin());
+
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+  EXPECT_TRUE(this->Map.begin() == this->Map.end());
+}
+
+// Test erase(value) method
+TYPED_TEST(DenseMapTest, EraseTest2) {
+  this->Map[this->getKey()] = this->getValue();
+  this->Map.erase(this->getKey());
+
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+  EXPECT_TRUE(this->Map.begin() == this->Map.end());
+}
+
+// Test insert() method
+TYPED_TEST(DenseMapTest, InsertTest) {
+  this->Map.insert(std::make_pair(this->getKey(), this->getValue()));
+  EXPECT_EQ(1u, this->Map.size());
+  EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
+}
+
+// Test copy constructor method
+TYPED_TEST(DenseMapTest, CopyConstructorTest) {
+  this->Map[this->getKey()] = this->getValue();
+  TypeParam copyMap(this->Map);
+
+  EXPECT_EQ(1u, copyMap.size());
+  EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
+}
+
+// Test copy constructor method where SmallDenseMap isn't small.
+TYPED_TEST(DenseMapTest, CopyConstructorNotSmallTest) {
+  for (int Key = 0; Key < 5; ++Key)
+    this->Map[this->getKey(Key)] = this->getValue(Key);
+  TypeParam copyMap(this->Map);
+
+  EXPECT_EQ(5u, copyMap.size());
+  for (int Key = 0; Key < 5; ++Key)
+    EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
+}
+
+// Test copying from a default-constructed map.
+TYPED_TEST(DenseMapTest, CopyConstructorFromDefaultTest) {
+  TypeParam copyMap(this->Map);
+
+  EXPECT_TRUE(copyMap.empty());
+}
+
+// Test copying from an empty map where SmallDenseMap isn't small.
+TYPED_TEST(DenseMapTest, CopyConstructorFromEmptyTest) {
+  for (int Key = 0; Key < 5; ++Key)
+    this->Map[this->getKey(Key)] = this->getValue(Key);
+  this->Map.clear();
+  TypeParam copyMap(this->Map);
+
+  EXPECT_TRUE(copyMap.empty());
+}
+
+// Test assignment operator method
+TYPED_TEST(DenseMapTest, AssignmentTest) {
+  this->Map[this->getKey()] = this->getValue();
+  TypeParam copyMap = this->Map;
+
+  EXPECT_EQ(1u, copyMap.size());
+  EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
+
+  // test self-assignment.
+  copyMap = static_cast<TypeParam &>(copyMap);
+  EXPECT_EQ(1u, copyMap.size());
+  EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
+}
+
+TYPED_TEST(DenseMapTest, AssignmentTestNotSmall) {
+  for (int Key = 0; Key < 5; ++Key)
+    this->Map[this->getKey(Key)] = this->getValue(Key);
+  TypeParam copyMap = this->Map;
+
+  EXPECT_EQ(5u, copyMap.size());
+  for (int Key = 0; Key < 5; ++Key)
+    EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
+
+  // test self-assignment.
+  copyMap = static_cast<TypeParam &>(copyMap);
+  EXPECT_EQ(5u, copyMap.size());
+  for (int Key = 0; Key < 5; ++Key)
+    EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
+}
+
+// Test swap method
+TYPED_TEST(DenseMapTest, SwapTest) {
+  this->Map[this->getKey()] = this->getValue();
+  TypeParam otherMap;
+
+  this->Map.swap(otherMap);
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+  EXPECT_EQ(1u, otherMap.size());
+  EXPECT_EQ(this->getValue(), otherMap[this->getKey()]);
+
+  this->Map.swap(otherMap);
+  EXPECT_EQ(0u, otherMap.size());
+  EXPECT_TRUE(otherMap.empty());
+  EXPECT_EQ(1u, this->Map.size());
+  EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
+
+  // Make this more interesting by inserting 100 numbers into the map.
+  for (int i = 0; i < 100; ++i)
+    this->Map[this->getKey(i)] = this->getValue(i);
+
+  this->Map.swap(otherMap);
+  EXPECT_EQ(0u, this->Map.size());
+  EXPECT_TRUE(this->Map.empty());
+  EXPECT_EQ(100u, otherMap.size());
+  for (int i = 0; i < 100; ++i)
+    EXPECT_EQ(this->getValue(i), otherMap[this->getKey(i)]);
+
+  this->Map.swap(otherMap);
+  EXPECT_EQ(0u, otherMap.size());
+  EXPECT_TRUE(otherMap.empty());
+  EXPECT_EQ(100u, this->Map.size());
+  for (int i = 0; i < 100; ++i)
+    EXPECT_EQ(this->getValue(i), this->Map[this->getKey(i)]);
+}
+
+// A more complex iteration test
+TYPED_TEST(DenseMapTest, IterationTest) {
+  bool visited[100];
+  std::map<typename TypeParam::key_type, unsigned> visitedIndex;
+
+  // Insert 100 numbers into the map
+  for (int i = 0; i < 100; ++i) {
+    visited[i] = false;
+    visitedIndex[this->getKey(i)] = i;
+
+    this->Map[this->getKey(i)] = this->getValue(i);
+  }
+
+  // Iterate over all numbers and mark each one found.
+  for (typename TypeParam::iterator it = this->Map.begin();
+       it != this->Map.end(); ++it)
+    visited[visitedIndex[it->first]] = true;
+
+  // Ensure every number was visited.
+  for (int i = 0; i < 100; ++i)
+    ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
+}
+
+// const_iterator test
+TYPED_TEST(DenseMapTest, ConstIteratorTest) {
+  // Check conversion from iterator to const_iterator.
+  typename TypeParam::iterator it = this->Map.begin();
+  typename TypeParam::const_iterator cit(it);
+  EXPECT_TRUE(it == cit);
+
+  // Check copying of const_iterators.
+  typename TypeParam::const_iterator cit2(cit);
+  EXPECT_TRUE(cit == cit2);
+}
+
+namespace {
+// Simple class that counts how many moves and copy happens when growing a map
+struct CountCopyAndMove {
+  static int Move;
+  static int Copy;
+  CountCopyAndMove() {}
+
+  CountCopyAndMove(const CountCopyAndMove &) { Copy++; }
+  CountCopyAndMove &operator=(const CountCopyAndMove &) {
+    Copy++;
+    return *this;
+  }
+  CountCopyAndMove(CountCopyAndMove &&) { Move++; }
+  CountCopyAndMove &operator=(const CountCopyAndMove &&) {
+    Move++;
+    return *this;
+  }
+};
+int CountCopyAndMove::Copy = 0;
+int CountCopyAndMove::Move = 0;
+
+} // anonymous namespace
+
+// Test initializer list construction.
+TEST(DenseMapCustomTest, InitializerList) {
+  DenseMap<int, int> M({{0, 0}, {0, 1}, {1, 2}});
+  EXPECT_EQ(2u, M.size());
+  EXPECT_EQ(1u, M.count(0));
+  EXPECT_EQ(0, M[0]);
+  EXPECT_EQ(1u, M.count(1));
+  EXPECT_EQ(2, M[1]);
+}
+
+// Test initializer list construction.
+TEST(DenseMapCustomTest, EqualityComparison) {
+  DenseMap<int, int> M1({{0, 0}, {1, 2}});
+  DenseMap<int, int> M2({{0, 0}, {1, 2}});
+  DenseMap<int, int> M3({{0, 0}, {1, 3}});
+
+  EXPECT_EQ(M1, M2);
+  EXPECT_NE(M1, M3);
+}
+
+// Test for the default minimum size of a DenseMap
+TEST(DenseMapCustomTest, DefaultMinReservedSizeTest) {
+  // IF THIS VALUE CHANGE, please update InitialSizeTest, InitFromIterator, and
+  // ReserveTest as well!
+  const int ExpectedInitialBucketCount = 64;
+  // Formula from DenseMap::getMinBucketToReserveForEntries()
+  const int ExpectedMaxInitialEntries = ExpectedInitialBucketCount * 3 / 4 - 1;
+
+  DenseMap<int, CountCopyAndMove> Map;
+  // Will allocate 64 buckets
+  Map.reserve(1);
+  unsigned MemorySize = Map.getMemorySize();
+  CountCopyAndMove::Copy = 0;
+  CountCopyAndMove::Move = 0;
+  for (int i = 0; i < ExpectedMaxInitialEntries; ++i)
+    Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
+                                                std::forward_as_tuple(i),
+                                                std::forward_as_tuple()));
+  // Check that we didn't grow
+  EXPECT_EQ(MemorySize, Map.getMemorySize());
+  // Check that move was called the expected number of times
+  EXPECT_EQ(ExpectedMaxInitialEntries, CountCopyAndMove::Move);
+  // Check that no copy occurred
+  EXPECT_EQ(0, CountCopyAndMove::Copy);
+
+  // Adding one extra element should grow the map
+  Map.insert(std::pair<int, CountCopyAndMove>(
+      std::piecewise_construct,
+      std::forward_as_tuple(ExpectedMaxInitialEntries),
+      std::forward_as_tuple()));
+  // Check that we grew
+  EXPECT_NE(MemorySize, Map.getMemorySize());
+  // Check that move was called the expected number of times
+  //  This relies on move-construction elision, and cannot be reliably tested.
+  //   EXPECT_EQ(ExpectedMaxInitialEntries + 2, CountCopyAndMove::Move);
+  // Check that no copy occurred
+  EXPECT_EQ(0, CountCopyAndMove::Copy);
+}
+
+// Make sure creating the map with an initial size of N actually gives us enough
+// buckets to insert N items without increasing allocation size.
+TEST(DenseMapCustomTest, InitialSizeTest) {
+  // Test a few different sizes, 48 is *not* a random choice: we need a value
+  // that is 2/3 of a power of two to stress the grow() condition, and the power
+  // of two has to be at least 64 because of minimum size allocation in the
+  // DenseMap (see DefaultMinReservedSizeTest). 66 is a value just above the
+  // 64 default init.
+  for (auto Size : {1, 2, 48, 66}) {
+    DenseMap<int, CountCopyAndMove> Map(Size);
+    unsigned MemorySize = Map.getMemorySize();
+    CountCopyAndMove::Copy = 0;
+    CountCopyAndMove::Move = 0;
+    for (int i = 0; i < Size; ++i)
+      Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
+                                                  std::forward_as_tuple(i),
+                                                  std::forward_as_tuple()));
+    // Check that we didn't grow
+    EXPECT_EQ(MemorySize, Map.getMemorySize());
+    // Check that move was called the expected number of times
+    EXPECT_EQ(Size, CountCopyAndMove::Move);
+    // Check that no copy occurred
+    EXPECT_EQ(0, CountCopyAndMove::Copy);
+  }
+}
+
+// Make sure creating the map with a iterator range does not trigger grow()
+TEST(DenseMapCustomTest, InitFromIterator) {
+  std::vector<std::pair<int, CountCopyAndMove>> Values;
+  // The size is a random value greater than 64 (hardcoded DenseMap min init)
+  const int Count = 65;
+  for (int i = 0; i < Count; i++)
+    Values.emplace_back(i, CountCopyAndMove());
+
+  CountCopyAndMove::Move = 0;
+  CountCopyAndMove::Copy = 0;
+  DenseMap<int, CountCopyAndMove> Map(Values.begin(), Values.end());
+  // Check that no move occurred
+  EXPECT_EQ(0, CountCopyAndMove::Move);
+  // Check that copy was called the expected number of times
+  EXPECT_EQ(Count, CountCopyAndMove::Copy);
+}
+
+// Make sure reserve actually gives us enough buckets to insert N items
+// without increasing allocation size.
+TEST(DenseMapCustomTest, ReserveTest) {
+  // Test a few different size, 48 is *not* a random choice: we need a value
+  // that is 2/3 of a power of two to stress the grow() condition, and the power
+  // of two has to be at least 64 because of minimum size allocation in the
+  // DenseMap (see DefaultMinReservedSizeTest). 66 is a value just above the
+  // 64 default init.
+  for (auto Size : {1, 2, 48, 66}) {
+    DenseMap<int, CountCopyAndMove> Map;
+    Map.reserve(Size);
+    unsigned MemorySize = Map.getMemorySize();
+    CountCopyAndMove::Copy = 0;
+    CountCopyAndMove::Move = 0;
+    for (int i = 0; i < Size; ++i)
+      Map.insert(std::pair<int, CountCopyAndMove>(std::piecewise_construct,
+                                                  std::forward_as_tuple(i),
+                                                  std::forward_as_tuple()));
+    // Check that we didn't grow
+    EXPECT_EQ(MemorySize, Map.getMemorySize());
+    // Check that move was called the expected number of times
+    EXPECT_EQ(Size, CountCopyAndMove::Move);
+    // Check that no copy occurred
+    EXPECT_EQ(0, CountCopyAndMove::Copy);
+  }
+}
+
+// Key traits that allows lookup with either an unsigned or char* key;
+// In the latter case, "a" == 0, "b" == 1 and so on.
+struct TestDenseMapInfo {
+  static inline unsigned getEmptyKey() { return ~0; }
+  static inline unsigned getTombstoneKey() { return ~0U - 1; }
+  static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
+  static unsigned getHashValue(const char* Val) {
+    return (unsigned)(Val[0] - 'a') * 37U;
+  }
+  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
+    return LHS == RHS;
+  }
+  static bool isEqual(const char* LHS, const unsigned& RHS) {
+    return (unsigned)(LHS[0] - 'a') == RHS;
+  }
+};
+
+// find_as() tests
+TEST(DenseMapCustomTest, FindAsTest) {
+  DenseMap<unsigned, unsigned, TestDenseMapInfo> map;
+  map[0] = 1;
+  map[1] = 2;
+  map[2] = 3;
+
+  // Size tests
+  EXPECT_EQ(3u, map.size());
+
+  // Normal lookup tests
+  EXPECT_EQ(1u, map.count(1));
+  EXPECT_EQ(1u, map.find(0)->second);
+  EXPECT_EQ(2u, map.find(1)->second);
+  EXPECT_EQ(3u, map.find(2)->second);
+  EXPECT_TRUE(map.find(3) == map.end());
+
+  // find_as() tests
+  EXPECT_EQ(1u, map.find_as("a")->second);
+  EXPECT_EQ(2u, map.find_as("b")->second);
+  EXPECT_EQ(3u, map.find_as("c")->second);
+  EXPECT_TRUE(map.find_as("d") == map.end());
+}
+
+TEST(DenseMapCustomTest, SmallDenseMapInitializerList) {
+  SmallDenseMap<int, int> M = {{0, 0}, {0, 1}, {1, 2}};
+  EXPECT_EQ(2u, M.size());
+  EXPECT_EQ(1u, M.count(0));
+  EXPECT_EQ(0, M[0]);
+  EXPECT_EQ(1u, M.count(1));
+  EXPECT_EQ(2, M[1]);
+}
+
+struct ContiguousDenseMapInfo {
+  static inline unsigned getEmptyKey() { return ~0; }
+  static inline unsigned getTombstoneKey() { return ~0U - 1; }
+  static unsigned getHashValue(const unsigned& Val) { return Val; }
+  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
+    return LHS == RHS;
+  }
+};
+
+// Test that filling a small dense map with exactly the number of elements in
+// the map grows to have enough space for an empty bucket.
+TEST(DenseMapCustomTest, SmallDenseMapGrowTest) {
+  SmallDenseMap<unsigned, unsigned, 32, ContiguousDenseMapInfo> map;
+  // Add some number of elements, then delete a few to leave us some tombstones.
+  // If we just filled the map with 32 elements we'd grow because of not enough
+  // tombstones which masks the issue here.
+  for (unsigned i = 0; i < 20; ++i)
+    map[i] = i + 1;
+  for (unsigned i = 0; i < 10; ++i)
+    map.erase(i);
+  for (unsigned i = 20; i < 32; ++i)
+    map[i] = i + 1;
+
+  // Size tests
+  EXPECT_EQ(22u, map.size());
+
+  // Try to find an element which doesn't exist.  There was a bug in
+  // SmallDenseMap which led to a map with num elements == small capacity not
+  // having an empty bucket any more.  Finding an element not in the map would
+  // therefore never terminate.
+  EXPECT_TRUE(map.find(32) == map.end());
+}
+
+TEST(DenseMapCustomTest, LargeSmallDenseMapCompaction) {
+  SmallDenseMap<unsigned, unsigned, 128, ContiguousDenseMapInfo> map;
+  // Fill to < 3/4 load.
+  for (unsigned i = 0; i < 95; ++i)
+    map[i] = i;
+  // And erase, leaving behind tombstones.
+  for (unsigned i = 0; i < 95; ++i)
+    map.erase(i);
+  // Fill further, so that less than 1/8 are empty, but still below 3/4 load.
+  for (unsigned i = 95; i < 128; ++i)
+    map[i] = i;
+
+  EXPECT_EQ(33u, map.size());
+  // Similar to the previous test, check for a non-existing element, as an
+  // indirect check that tombstones have been removed.
+  EXPECT_TRUE(map.find(0) == map.end());
+}
+
+TEST(DenseMapCustomTest, TryEmplaceTest) {
+  DenseMap<int, std::unique_ptr<int>> Map;
+  std::unique_ptr<int> P(new int(2));
+  auto Try1 = Map.try_emplace(0, new int(1));
+  EXPECT_TRUE(Try1.second);
+  auto Try2 = Map.try_emplace(0, std::move(P));
+  EXPECT_FALSE(Try2.second);
+  EXPECT_EQ(Try1.first, Try2.first);
+  EXPECT_NE(nullptr, P);
+}
+
+TEST(DenseMapCustomTest, ConstTest) {
+  // Test that const pointers work okay for count and find, even when the
+  // underlying map is a non-const pointer.
+  DenseMap<int *, int> Map;
+  int A;
+  int *B = &A;
+  const int *C = &A;
+  Map.insert({B, 0});
+  EXPECT_EQ(Map.count(B), 1u);
+  EXPECT_EQ(Map.count(C), 1u);
+  EXPECT_NE(Map.find(B), Map.end());
+  EXPECT_NE(Map.find(C), Map.end());
+}
+
+struct IncompleteStruct;
+
+TEST(DenseMapCustomTest, OpaquePointerKey) {
+  // Test that we can use a pointer to an incomplete type as a DenseMap key.
+  // This is an important build time optimization, since many classes have
+  // DenseMap members.
+  DenseMap<IncompleteStruct *, int> Map;
+  int Keys[3] = {0, 0, 0};
+  IncompleteStruct *K1 = reinterpret_cast<IncompleteStruct *>(&Keys[0]);
+  IncompleteStruct *K2 = reinterpret_cast<IncompleteStruct *>(&Keys[1]);
+  IncompleteStruct *K3 = reinterpret_cast<IncompleteStruct *>(&Keys[2]);
+  Map.insert({K1, 1});
+  Map.insert({K2, 2});
+  Map.insert({K3, 3});
+  EXPECT_EQ(Map.count(K1), 1u);
+  EXPECT_EQ(Map[K1], 1);
+  EXPECT_EQ(Map[K2], 2);
+  EXPECT_EQ(Map[K3], 3);
+  Map.clear();
+  EXPECT_EQ(Map.find(K1), Map.end());
+  EXPECT_EQ(Map.find(K2), Map.end());
+  EXPECT_EQ(Map.find(K3), Map.end());
+}
+} // namespace
+
+namespace {
+struct A {
+  A(int value) : value(value) {}
+  int value;
+};
+struct B : public A {
+  using A::A;
+};
+} // namespace
+
+namespace wpi {
+template <typename T>
+struct DenseMapInfo<T, std::enable_if_t<std::is_base_of<A, T>::value>> {
+  static inline T getEmptyKey() { return {static_cast<int>(~0)}; }
+  static inline T getTombstoneKey() { return {static_cast<int>(~0U - 1)}; }
+  static unsigned getHashValue(const T &Val) { return Val.value; }
+  static bool isEqual(const T &LHS, const T &RHS) {
+    return LHS.value == RHS.value;
+  }
+};
+} // namespace wpi
+
+namespace {
+TEST(DenseMapCustomTest, SFINAEMapInfo) {
+  // Test that we can use a pointer to an incomplete type as a DenseMap key.
+  // This is an important build time optimization, since many classes have
+  // DenseMap members.
+  DenseMap<B, int> Map;
+  B Keys[3] = {{0}, {1}, {2}};
+  Map.insert({Keys[0], 1});
+  Map.insert({Keys[1], 2});
+  Map.insert({Keys[2], 3});
+  EXPECT_EQ(Map.count(Keys[0]), 1u);
+  EXPECT_EQ(Map[Keys[0]], 1);
+  EXPECT_EQ(Map[Keys[1]], 2);
+  EXPECT_EQ(Map[Keys[2]], 3);
+  Map.clear();
+  EXPECT_EQ(Map.find(Keys[0]), Map.end());
+  EXPECT_EQ(Map.find(Keys[1]), Map.end());
+  EXPECT_EQ(Map.find(Keys[2]), Map.end());
+}
+} // namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/EndianTest.cpp b/wpiutil/src/test/native/cpp/llvm/EndianTest.cpp
new file mode 100644
index 0000000..89edec4
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/EndianTest.cpp
@@ -0,0 +1,211 @@
+//===- unittests/Support/EndianTest.cpp - Endian.h tests ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/Endian.h"
+#include "gtest/gtest.h"
+#include <cstdlib>
+#include <ctime>
+using namespace wpi;
+using namespace support;
+
+#undef max
+
+namespace {
+
+TEST(Endian, Read) {
+  // These are 5 bytes so we can be sure at least one of the reads is unaligned.
+  unsigned char bigval[] = {0x00, 0x01, 0x02, 0x03, 0x04};
+  unsigned char littleval[] = {0x00, 0x04, 0x03, 0x02, 0x01};
+  int32_t BigAsHost = 0x00010203;
+  EXPECT_EQ(BigAsHost, (endian::read<int32_t, big, unaligned>(bigval)));
+  int32_t LittleAsHost = 0x02030400;
+  EXPECT_EQ(LittleAsHost,(endian::read<int32_t, little, unaligned>(littleval)));
+
+  EXPECT_EQ((endian::read<int32_t, big, unaligned>(bigval + 1)),
+            (endian::read<int32_t, little, unaligned>(littleval + 1)));
+}
+
+TEST(Endian, ReadBitAligned) {
+  // Simple test to make sure we properly pull out the 0x0 word.
+  unsigned char littleval[] = {0x3f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff};
+  unsigned char bigval[] = {0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0};
+  EXPECT_EQ(
+      (endian::readAtBitAlignment<int, little, unaligned>(&littleval[0], 6)),
+      0x0);
+  EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval[0], 6)),
+            0x0);
+  // Test to make sure that signed right shift of 0xf0000000 is masked
+  // properly.
+  unsigned char littleval2[] = {0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00};
+  unsigned char bigval2[] = {0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  EXPECT_EQ(
+      (endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 4)),
+      0x0f000000);
+  EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 4)),
+            0x0f000000);
+  // Test to make sure left shift of start bit doesn't overflow.
+  EXPECT_EQ(
+      (endian::readAtBitAlignment<int, little, unaligned>(&littleval2[0], 1)),
+      0x78000000);
+  EXPECT_EQ((endian::readAtBitAlignment<int, big, unaligned>(&bigval2[0], 1)),
+            0x78000000);
+  // Test to make sure 64-bit int doesn't overflow.
+  unsigned char littleval3[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
+                                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  unsigned char bigval3[] = {0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  EXPECT_EQ((endian::readAtBitAlignment<int64_t, little, unaligned>(
+                &littleval3[0], 4)),
+            0x0f00000000000000);
+  EXPECT_EQ(
+      (endian::readAtBitAlignment<int64_t, big, unaligned>(&bigval3[0], 4)),
+      0x0f00000000000000);
+}
+
+TEST(Endian, WriteBitAligned) {
+  // This test ensures that signed right shift of 0xffffaa is masked
+  // properly.
+  unsigned char bigval[8] = {0x00};
+  endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval, (int)0xffffaaaa,
+                                                       4);
+  EXPECT_EQ(bigval[0], 0xff);
+  EXPECT_EQ(bigval[1], 0xfa);
+  EXPECT_EQ(bigval[2], 0xaa);
+  EXPECT_EQ(bigval[3], 0xa0);
+  EXPECT_EQ(bigval[4], 0x00);
+  EXPECT_EQ(bigval[5], 0x00);
+  EXPECT_EQ(bigval[6], 0x00);
+  EXPECT_EQ(bigval[7], 0x0f);
+
+  unsigned char littleval[8] = {0x00};
+  endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval,
+                                                          (int)0xffffaaaa, 4);
+  EXPECT_EQ(littleval[0], 0xa0);
+  EXPECT_EQ(littleval[1], 0xaa);
+  EXPECT_EQ(littleval[2], 0xfa);
+  EXPECT_EQ(littleval[3], 0xff);
+  EXPECT_EQ(littleval[4], 0x0f);
+  EXPECT_EQ(littleval[5], 0x00);
+  EXPECT_EQ(littleval[6], 0x00);
+  EXPECT_EQ(littleval[7], 0x00);
+
+  // This test makes sure 1<<31 doesn't overflow.
+  // Test to make sure left shift of start bit doesn't overflow.
+  unsigned char bigval2[8] = {0x00};
+  endian::writeAtBitAlignment<int32_t, big, unaligned>(bigval2, (int)0xffffffff,
+                                                       1);
+  EXPECT_EQ(bigval2[0], 0xff);
+  EXPECT_EQ(bigval2[1], 0xff);
+  EXPECT_EQ(bigval2[2], 0xff);
+  EXPECT_EQ(bigval2[3], 0xfe);
+  EXPECT_EQ(bigval2[4], 0x00);
+  EXPECT_EQ(bigval2[5], 0x00);
+  EXPECT_EQ(bigval2[6], 0x00);
+  EXPECT_EQ(bigval2[7], 0x01);
+
+  unsigned char littleval2[8] = {0x00};
+  endian::writeAtBitAlignment<int32_t, little, unaligned>(littleval2,
+                                                          (int)0xffffffff, 1);
+  EXPECT_EQ(littleval2[0], 0xfe);
+  EXPECT_EQ(littleval2[1], 0xff);
+  EXPECT_EQ(littleval2[2], 0xff);
+  EXPECT_EQ(littleval2[3], 0xff);
+  EXPECT_EQ(littleval2[4], 0x01);
+  EXPECT_EQ(littleval2[5], 0x00);
+  EXPECT_EQ(littleval2[6], 0x00);
+  EXPECT_EQ(littleval2[7], 0x00);
+
+  // Test to make sure 64-bit int doesn't overflow.
+  unsigned char bigval64[16] = {0x00};
+  endian::writeAtBitAlignment<int64_t, big, unaligned>(
+      bigval64, (int64_t)0xffffffffffffffff, 1);
+  EXPECT_EQ(bigval64[0], 0xff);
+  EXPECT_EQ(bigval64[1], 0xff);
+  EXPECT_EQ(bigval64[2], 0xff);
+  EXPECT_EQ(bigval64[3], 0xff);
+  EXPECT_EQ(bigval64[4], 0xff);
+  EXPECT_EQ(bigval64[5], 0xff);
+  EXPECT_EQ(bigval64[6], 0xff);
+  EXPECT_EQ(bigval64[7], 0xfe);
+  EXPECT_EQ(bigval64[8], 0x00);
+  EXPECT_EQ(bigval64[9], 0x00);
+  EXPECT_EQ(bigval64[10], 0x00);
+  EXPECT_EQ(bigval64[11], 0x00);
+  EXPECT_EQ(bigval64[12], 0x00);
+  EXPECT_EQ(bigval64[13], 0x00);
+  EXPECT_EQ(bigval64[14], 0x00);
+  EXPECT_EQ(bigval64[15], 0x01);
+
+  unsigned char littleval64[16] = {0x00};
+  endian::writeAtBitAlignment<int64_t, little, unaligned>(
+      littleval64, (int64_t)0xffffffffffffffff, 1);
+  EXPECT_EQ(littleval64[0], 0xfe);
+  EXPECT_EQ(littleval64[1], 0xff);
+  EXPECT_EQ(littleval64[2], 0xff);
+  EXPECT_EQ(littleval64[3], 0xff);
+  EXPECT_EQ(littleval64[4], 0xff);
+  EXPECT_EQ(littleval64[5], 0xff);
+  EXPECT_EQ(littleval64[6], 0xff);
+  EXPECT_EQ(littleval64[7], 0xff);
+  EXPECT_EQ(littleval64[8], 0x01);
+  EXPECT_EQ(littleval64[9], 0x00);
+  EXPECT_EQ(littleval64[10], 0x00);
+  EXPECT_EQ(littleval64[11], 0x00);
+  EXPECT_EQ(littleval64[12], 0x00);
+  EXPECT_EQ(littleval64[13], 0x00);
+  EXPECT_EQ(littleval64[14], 0x00);
+  EXPECT_EQ(littleval64[15], 0x00);
+}
+
+TEST(Endian, Write) {
+  unsigned char data[5];
+  endian::write<int32_t, big, unaligned>(data, -1362446643);
+  EXPECT_EQ(data[0], 0xAE);
+  EXPECT_EQ(data[1], 0xCA);
+  EXPECT_EQ(data[2], 0xB6);
+  EXPECT_EQ(data[3], 0xCD);
+  endian::write<int32_t, big, unaligned>(data + 1, -1362446643);
+  EXPECT_EQ(data[1], 0xAE);
+  EXPECT_EQ(data[2], 0xCA);
+  EXPECT_EQ(data[3], 0xB6);
+  EXPECT_EQ(data[4], 0xCD);
+
+  endian::write<int32_t, little, unaligned>(data, -1362446643);
+  EXPECT_EQ(data[0], 0xCD);
+  EXPECT_EQ(data[1], 0xB6);
+  EXPECT_EQ(data[2], 0xCA);
+  EXPECT_EQ(data[3], 0xAE);
+  endian::write<int32_t, little, unaligned>(data + 1, -1362446643);
+  EXPECT_EQ(data[1], 0xCD);
+  EXPECT_EQ(data[2], 0xB6);
+  EXPECT_EQ(data[3], 0xCA);
+  EXPECT_EQ(data[4], 0xAE);
+}
+
+TEST(Endian, PackedEndianSpecificIntegral) {
+  // These are 5 bytes so we can be sure at least one of the reads is unaligned.
+  unsigned char big[] = {0x00, 0x01, 0x02, 0x03, 0x04};
+  unsigned char little[] = {0x00, 0x04, 0x03, 0x02, 0x01};
+  big32_t    *big_val    =
+    reinterpret_cast<big32_t *>(big + 1);
+  little32_t *little_val =
+    reinterpret_cast<little32_t *>(little + 1);
+
+  EXPECT_EQ(*big_val, *little_val);
+}
+
+TEST(Endian, PacketEndianSpecificIntegralAsEnum) {
+  enum class Test : uint16_t { ONETWO = 0x0102, TWOONE = 0x0201 };
+  unsigned char bytes[] = {0x01, 0x02};
+  using LittleTest = little_t<Test>;
+  using BigTest = big_t<Test>;
+  EXPECT_EQ(Test::TWOONE, *reinterpret_cast<LittleTest *>(bytes));
+  EXPECT_EQ(Test::ONETWO, *reinterpret_cast<BigTest *>(bytes));
+}
+
+} // end anon namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/ErrnoTest.cpp b/wpiutil/src/test/native/cpp/llvm/ErrnoTest.cpp
new file mode 100644
index 0000000..fed8ad6
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/ErrnoTest.cpp
@@ -0,0 +1,38 @@
+//===- ErrnoTest.cpp - Error handling unit tests --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/Errno.h"
+#include "gtest/gtest.h"
+
+using namespace wpi::sys;
+
+TEST(ErrnoTest, RetryAfterSignal) {
+  EXPECT_EQ(1, RetryAfterSignal(-1, [] { return 1; }));
+
+  EXPECT_EQ(-1, RetryAfterSignal(-1, [] {
+    errno = EAGAIN;
+    return -1;
+  }));
+  EXPECT_EQ(EAGAIN, errno);
+
+  unsigned calls = 0;
+  EXPECT_EQ(1, RetryAfterSignal(-1, [&calls] {
+              errno = EINTR;
+              ++calls;
+              return calls == 1 ? -1 : 1;
+            }));
+  EXPECT_EQ(2u, calls);
+
+  EXPECT_EQ(1, RetryAfterSignal(-1, [](int x) { return x; }, 1));
+
+  std::unique_ptr<int> P(RetryAfterSignal(nullptr, [] { return new int(47); }));
+  EXPECT_EQ(47, *P);
+
+  errno = EINTR;
+  EXPECT_EQ(-1, RetryAfterSignal(-1, [] { return -1; }));
+}
diff --git a/wpiutil/src/test/native/cpp/llvm/FunctionExtrasTest.cpp b/wpiutil/src/test/native/cpp/llvm/FunctionExtrasTest.cpp
index 5dcd11f..53508cc 100644
--- a/wpiutil/src/test/native/cpp/llvm/FunctionExtrasTest.cpp
+++ b/wpiutil/src/test/native/cpp/llvm/FunctionExtrasTest.cpp
@@ -1,9 +1,8 @@
 //===- FunctionExtrasTest.cpp - Unit tests for function type erasure ------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -11,6 +10,7 @@
 #include "gtest/gtest.h"
 
 #include <memory>
+#include <type_traits>
 
 using namespace wpi;
 
@@ -225,4 +225,89 @@
   UnmovableF(X);
 }
 
+TEST(UniqueFunctionTest, Const) {
+  // Can assign from const lambda.
+  unique_function<int(int) const> Plus2 = [X(std::make_unique<int>(2))](int Y) {
+    return *X + Y;
+  };
+  EXPECT_EQ(5, Plus2(3));
+
+  // Can call through a const ref.
+  const auto &Plus2Ref = Plus2;
+  EXPECT_EQ(5, Plus2Ref(3));
+
+  // Can move-construct and assign.
+  unique_function<int(int) const> Plus2A = std::move(Plus2);
+  EXPECT_EQ(5, Plus2A(3));
+  unique_function<int(int) const> Plus2B;
+  Plus2B = std::move(Plus2A);
+  EXPECT_EQ(5, Plus2B(3));
+
+  // Can convert to non-const function type, but not back.
+  unique_function<int(int)> Plus2C = std::move(Plus2B);
+  EXPECT_EQ(5, Plus2C(3));
+
+  // Overloaded call operator correctly resolved.
+  struct ChooseCorrectOverload {
+    std::string_view operator()() { return "non-const"; }
+    std::string_view operator()() const { return "const"; }
+  };
+  unique_function<std::string_view()> ChooseMutable = ChooseCorrectOverload();
+  ChooseCorrectOverload A;
+  EXPECT_EQ("non-const", ChooseMutable());
+  EXPECT_EQ("non-const", A());
+  unique_function<std::string_view() const> ChooseConst = ChooseCorrectOverload();
+  const ChooseCorrectOverload &X = A;
+  EXPECT_EQ("const", ChooseConst());
+  EXPECT_EQ("const", X());
+}
+
+// Test that overloads on unique_functions are resolved as expected.
+std::string returns(std::string_view) { return "not a function"; }
+std::string returns(unique_function<double()> F) { return "number"; }
+std::string returns(unique_function<std::string_view()> F) { return "string"; }
+
+TEST(UniqueFunctionTest, SFINAE) {
+  EXPECT_EQ("not a function", returns("boo!"));
+  EXPECT_EQ("number", returns([] { return 42; }));
+  EXPECT_EQ("string", returns([] { return "hello"; }));
+}
+
+// A forward declared type, and a templated type.
+class Incomplete;
+template <typename T> class Templated { T A; };
+
+// Check that we can define unique_function that have references to
+// incomplete types, even if those types are templated over an
+// incomplete type.
+TEST(UniqueFunctionTest, IncompleteTypes) {
+  unique_function<void(Templated<Incomplete> &&)>
+      IncompleteArgumentRValueReference;
+  unique_function<void(Templated<Incomplete> &)>
+      IncompleteArgumentLValueReference;
+  unique_function<void(Templated<Incomplete> *)> IncompleteArgumentPointer;
+  unique_function<Templated<Incomplete> &()> IncompleteResultLValueReference;
+  unique_function<Templated<Incomplete> && ()> IncompleteResultRValueReference2;
+  unique_function<Templated<Incomplete> *()> IncompleteResultPointer;
+}
+
+// Incomplete function returning an incomplete type
+Incomplete incompleteFunction();
+const Incomplete incompleteFunctionConst();
+
+// Check that we can assign a callable to a unique_function when the
+// callable return value is incomplete.
+TEST(UniqueFunctionTest, IncompleteCallableType) {
+  unique_function<Incomplete()> IncompleteReturnInCallable{incompleteFunction};
+  unique_function<const Incomplete()> IncompleteReturnInCallableConst{
+      incompleteFunctionConst};
+  unique_function<const Incomplete()> IncompleteReturnInCallableConstConversion{
+      incompleteFunction};
+}
+
+// Define the incomplete function
+class Incomplete {};
+Incomplete incompleteFunction() { return {}; }
+const Incomplete incompleteFunctionConst() { return {}; }
+
 } // anonymous namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/MapVectorTest.cpp b/wpiutil/src/test/native/cpp/llvm/MapVectorTest.cpp
new file mode 100644
index 0000000..99bda8a
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/MapVectorTest.cpp
@@ -0,0 +1,430 @@
+//===- unittest/ADT/MapVectorTest.cpp - MapVector unit tests ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wpedantic"
+#if !defined(__clang__)
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+#endif
+
+#include "wpi/MapVector.h"
+#include "wpi/iterator_range.h"
+#include "gtest/gtest.h"
+#include <utility>
+
+using namespace wpi;
+
+TEST(MapVectorTest, swap) {
+  MapVector<int, int> MV1, MV2;
+  std::pair<MapVector<int, int>::iterator, bool> R;
+
+  R = MV1.insert(std::make_pair(1, 2));
+  ASSERT_EQ(R.first, MV1.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_FALSE(MV1.empty());
+  EXPECT_TRUE(MV2.empty());
+  MV2.swap(MV1);
+  EXPECT_TRUE(MV1.empty());
+  EXPECT_FALSE(MV2.empty());
+
+  auto I = MV1.find(1);
+  ASSERT_EQ(MV1.end(), I);
+
+  I = MV2.find(1);
+  ASSERT_EQ(I, MV2.begin());
+  EXPECT_EQ(I->first, 1);
+  EXPECT_EQ(I->second, 2);
+}
+
+TEST(MapVectorTest, insert_pop) {
+  MapVector<int, int> MV;
+  std::pair<MapVector<int, int>::iterator, bool> R;
+
+  R = MV.insert(std::make_pair(1, 2));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_TRUE(R.second);
+
+  R = MV.insert(std::make_pair(1, 3));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_FALSE(R.second);
+
+  R = MV.insert(std::make_pair(4, 5));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 5);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 5);
+
+  MV.pop_back();
+  EXPECT_EQ(MV.size(), 1u);
+  EXPECT_EQ(MV[1], 2);
+
+  R = MV.insert(std::make_pair(4, 7));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 7);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 7);
+}
+
+TEST(MapVectorTest, erase) {
+  MapVector<int, int> MV;
+
+  MV.insert(std::make_pair(1, 2));
+  MV.insert(std::make_pair(3, 4));
+  MV.insert(std::make_pair(5, 6));
+  ASSERT_EQ(MV.size(), 3u);
+
+  MV.erase(MV.find(1));
+  ASSERT_EQ(MV.size(), 2u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV[3], 4);
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(3), 1u);
+  ASSERT_EQ(MV.size(), 1u);
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(79), 0u);
+  ASSERT_EQ(MV.size(), 1u);
+}
+
+TEST(MapVectorTest, remove_if) {
+  MapVector<int, int> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  MV.remove_if([](const std::pair<int, int> &Val) { return Val.second % 2; });
+  ASSERT_EQ(MV.size(), 3u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV.find(5), MV.end());
+  ASSERT_EQ(MV[2], 12);
+  ASSERT_EQ(MV[4], 14);
+  ASSERT_EQ(MV[6], 16);
+}
+
+TEST(MapVectorTest, iteration_test) {
+  MapVector<int, int> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  int count = 1;
+  for (auto P : make_range(MV.begin(), MV.end())) {
+    ASSERT_EQ(P.first, count);
+    count++;
+  }
+
+  count = 6;
+  for (auto P : make_range(MV.rbegin(), MV.rend())) {
+    ASSERT_EQ(P.first, count);
+    count--;
+  }
+}
+
+TEST(MapVectorTest, NonCopyable) {
+  MapVector<int, std::unique_ptr<int>> MV;
+  MV.insert(std::make_pair(1, std::make_unique<int>(1)));
+  MV.insert(std::make_pair(2, std::make_unique<int>(2)));
+
+  ASSERT_EQ(MV.count(1), 1u);
+  ASSERT_EQ(*MV.find(2)->second, 2);
+}
+
+template <class IntType> struct MapVectorMappedTypeTest : ::testing::Test {
+  using int_type = IntType;
+};
+
+using MapIntTypes = ::testing::Types<int, long, long long, unsigned,
+                                     unsigned long, unsigned long long>;
+TYPED_TEST_SUITE(MapVectorMappedTypeTest, MapIntTypes, );
+
+TYPED_TEST(MapVectorMappedTypeTest, DifferentDenseMap) {
+  // Test that using a map with a mapped type other than 'unsigned' compiles
+  // and works.
+  using IntType = typename TestFixture::int_type;
+  using MapVectorType = MapVector<int, int, DenseMap<int, IntType>>;
+
+  MapVectorType MV;
+  std::pair<typename MapVectorType::iterator, bool> R;
+
+  R = MV.insert(std::make_pair(1, 2));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_TRUE(R.second);
+
+  const std::pair<int, int> Elem(1, 3);
+  R = MV.insert(Elem);
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_FALSE(R.second);
+
+  int& value = MV[4];
+  EXPECT_EQ(value, 0);
+  value = 5;
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 5);
+}
+
+TEST(SmallMapVectorSmallTest, insert_pop) {
+  SmallMapVector<int, int, 32> MV;
+  std::pair<SmallMapVector<int, int, 32>::iterator, bool> R;
+
+  R = MV.insert(std::make_pair(1, 2));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_TRUE(R.second);
+
+  R = MV.insert(std::make_pair(1, 3));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_FALSE(R.second);
+
+  R = MV.insert(std::make_pair(4, 5));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 5);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 5);
+
+  MV.pop_back();
+  EXPECT_EQ(MV.size(), 1u);
+  EXPECT_EQ(MV[1], 2);
+
+  R = MV.insert(std::make_pair(4, 7));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 7);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 7);
+}
+
+TEST(SmallMapVectorSmallTest, erase) {
+  SmallMapVector<int, int, 32> MV;
+
+  MV.insert(std::make_pair(1, 2));
+  MV.insert(std::make_pair(3, 4));
+  MV.insert(std::make_pair(5, 6));
+  ASSERT_EQ(MV.size(), 3u);
+
+  MV.erase(MV.find(1));
+  ASSERT_EQ(MV.size(), 2u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV[3], 4);
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(3), 1u);
+  ASSERT_EQ(MV.size(), 1u);
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(79), 0u);
+  ASSERT_EQ(MV.size(), 1u);
+}
+
+TEST(SmallMapVectorSmallTest, remove_if) {
+  SmallMapVector<int, int, 32> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  MV.remove_if([](const std::pair<int, int> &Val) { return Val.second % 2; });
+  ASSERT_EQ(MV.size(), 3u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV.find(5), MV.end());
+  ASSERT_EQ(MV[2], 12);
+  ASSERT_EQ(MV[4], 14);
+  ASSERT_EQ(MV[6], 16);
+}
+
+TEST(SmallMapVectorSmallTest, iteration_test) {
+  SmallMapVector<int, int, 32> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  int count = 1;
+  for (auto P : make_range(MV.begin(), MV.end())) {
+    ASSERT_EQ(P.first, count);
+    count++;
+  }
+
+  count = 6;
+  for (auto P : make_range(MV.rbegin(), MV.rend())) {
+    ASSERT_EQ(P.first, count);
+    count--;
+  }
+}
+
+TEST(SmallMapVectorSmallTest, NonCopyable) {
+  SmallMapVector<int, std::unique_ptr<int>, 8> MV;
+  MV.insert(std::make_pair(1, std::make_unique<int>(1)));
+  MV.insert(std::make_pair(2, std::make_unique<int>(2)));
+
+  ASSERT_EQ(MV.count(1), 1u);
+  ASSERT_EQ(*MV.find(2)->second, 2);
+}
+
+TEST(SmallMapVectorLargeTest, insert_pop) {
+  SmallMapVector<int, int, 1> MV;
+  std::pair<SmallMapVector<int, int, 1>::iterator, bool> R;
+
+  R = MV.insert(std::make_pair(1, 2));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_TRUE(R.second);
+
+  R = MV.insert(std::make_pair(1, 3));
+  ASSERT_EQ(R.first, MV.begin());
+  EXPECT_EQ(R.first->first, 1);
+  EXPECT_EQ(R.first->second, 2);
+  EXPECT_FALSE(R.second);
+
+  R = MV.insert(std::make_pair(4, 5));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 5);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 5);
+
+  MV.pop_back();
+  EXPECT_EQ(MV.size(), 1u);
+  EXPECT_EQ(MV[1], 2);
+
+  R = MV.insert(std::make_pair(4, 7));
+  ASSERT_NE(R.first, MV.end());
+  EXPECT_EQ(R.first->first, 4);
+  EXPECT_EQ(R.first->second, 7);
+  EXPECT_TRUE(R.second);
+
+  EXPECT_EQ(MV.size(), 2u);
+  EXPECT_EQ(MV[1], 2);
+  EXPECT_EQ(MV[4], 7);
+}
+
+TEST(SmallMapVectorLargeTest, erase) {
+  SmallMapVector<int, int, 1> MV;
+
+  MV.insert(std::make_pair(1, 2));
+  MV.insert(std::make_pair(3, 4));
+  MV.insert(std::make_pair(5, 6));
+  ASSERT_EQ(MV.size(), 3u);
+
+  MV.erase(MV.find(1));
+  ASSERT_EQ(MV.size(), 2u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV[3], 4);
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(3), 1u);
+  ASSERT_EQ(MV.size(), 1u);
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV[5], 6);
+
+  ASSERT_EQ(MV.erase(79), 0u);
+  ASSERT_EQ(MV.size(), 1u);
+}
+
+TEST(SmallMapVectorLargeTest, remove_if) {
+  SmallMapVector<int, int, 1> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  MV.remove_if([](const std::pair<int, int> &Val) { return Val.second % 2; });
+  ASSERT_EQ(MV.size(), 3u);
+  ASSERT_EQ(MV.find(1), MV.end());
+  ASSERT_EQ(MV.find(3), MV.end());
+  ASSERT_EQ(MV.find(5), MV.end());
+  ASSERT_EQ(MV[2], 12);
+  ASSERT_EQ(MV[4], 14);
+  ASSERT_EQ(MV[6], 16);
+}
+
+TEST(SmallMapVectorLargeTest, iteration_test) {
+  SmallMapVector<int, int, 1> MV;
+
+  MV.insert(std::make_pair(1, 11));
+  MV.insert(std::make_pair(2, 12));
+  MV.insert(std::make_pair(3, 13));
+  MV.insert(std::make_pair(4, 14));
+  MV.insert(std::make_pair(5, 15));
+  MV.insert(std::make_pair(6, 16));
+  ASSERT_EQ(MV.size(), 6u);
+
+  int count = 1;
+  for (auto P : make_range(MV.begin(), MV.end())) {
+    ASSERT_EQ(P.first, count);
+    count++;
+  }
+
+  count = 6;
+  for (auto P : make_range(MV.rbegin(), MV.rend())) {
+    ASSERT_EQ(P.first, count);
+    count--;
+  }
+}
diff --git a/wpiutil/src/test/native/cpp/llvm/MathExtrasTest.cpp b/wpiutil/src/test/native/cpp/llvm/MathExtrasTest.cpp
new file mode 100644
index 0000000..f392887
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/MathExtrasTest.cpp
@@ -0,0 +1,607 @@
+//===- unittests/Support/MathExtrasTest.cpp - math utils tests ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/MathExtras.h"
+#include "gtest/gtest.h"
+
+using namespace wpi;
+
+namespace {
+
+TEST(MathExtras, countTrailingZeros) {
+  uint8_t Z8 = 0;
+  uint16_t Z16 = 0;
+  uint32_t Z32 = 0;
+  uint64_t Z64 = 0;
+  EXPECT_EQ(8u, countTrailingZeros(Z8));
+  EXPECT_EQ(16u, countTrailingZeros(Z16));
+  EXPECT_EQ(32u, countTrailingZeros(Z32));
+  EXPECT_EQ(64u, countTrailingZeros(Z64));
+
+  uint8_t NZ8 = 42;
+  uint16_t NZ16 = 42;
+  uint32_t NZ32 = 42;
+  uint64_t NZ64 = 42;
+  EXPECT_EQ(1u, countTrailingZeros(NZ8));
+  EXPECT_EQ(1u, countTrailingZeros(NZ16));
+  EXPECT_EQ(1u, countTrailingZeros(NZ32));
+  EXPECT_EQ(1u, countTrailingZeros(NZ64));
+}
+
+TEST(MathExtras, countLeadingZeros) {
+  uint8_t Z8 = 0;
+  uint16_t Z16 = 0;
+  uint32_t Z32 = 0;
+  uint64_t Z64 = 0;
+  EXPECT_EQ(8u, countLeadingZeros(Z8));
+  EXPECT_EQ(16u, countLeadingZeros(Z16));
+  EXPECT_EQ(32u, countLeadingZeros(Z32));
+  EXPECT_EQ(64u, countLeadingZeros(Z64));
+
+  uint8_t NZ8 = 42;
+  uint16_t NZ16 = 42;
+  uint32_t NZ32 = 42;
+  uint64_t NZ64 = 42;
+  EXPECT_EQ(2u, countLeadingZeros(NZ8));
+  EXPECT_EQ(10u, countLeadingZeros(NZ16));
+  EXPECT_EQ(26u, countLeadingZeros(NZ32));
+  EXPECT_EQ(58u, countLeadingZeros(NZ64));
+
+  EXPECT_EQ(8u, countLeadingZeros(0x00F000FFu));
+  EXPECT_EQ(8u, countLeadingZeros(0x00F12345u));
+  for (unsigned i = 0; i <= 30; ++i) {
+    EXPECT_EQ(31 - i, countLeadingZeros(1u << i));
+  }
+
+  EXPECT_EQ(8u, countLeadingZeros(0x00F1234500F12345ULL));
+  EXPECT_EQ(1u, countLeadingZeros(1ULL << 62));
+  for (unsigned i = 0; i <= 62; ++i) {
+    EXPECT_EQ(63 - i, countLeadingZeros(1ULL << i));
+  }
+}
+
+TEST(MathExtras, onesMask) {
+  EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0));
+  EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0));
+  EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0));
+  EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0));
+  EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0));
+  EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0));
+  EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0));
+  EXPECT_EQ(0U, maskTrailingOnes<uint64_t>(0));
+
+  EXPECT_EQ(0x00000003U, maskTrailingOnes<uint32_t>(2U));
+  EXPECT_EQ(0xC0000000U, maskLeadingOnes<uint32_t>(2U));
+
+  EXPECT_EQ(0x000007FFU, maskTrailingOnes<uint32_t>(11U));
+  EXPECT_EQ(0xFFE00000U, maskLeadingOnes<uint32_t>(11U));
+
+  EXPECT_EQ(0xFFFFFFFFU, maskTrailingOnes<uint32_t>(32U));
+  EXPECT_EQ(0xFFFFFFFFU, maskLeadingOnes<uint32_t>(32U));
+  EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(64U));
+  EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskLeadingOnes<uint64_t>(64U));
+
+  EXPECT_EQ(0x0000FFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(48U));
+  EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U));
+}
+
+TEST(MathExtras, findFirstSet) {
+  uint8_t Z8 = 0;
+  uint16_t Z16 = 0;
+  uint32_t Z32 = 0;
+  uint64_t Z64 = 0;
+  EXPECT_EQ(0xFFULL, findFirstSet(Z8));
+  EXPECT_EQ(0xFFFFULL, findFirstSet(Z16));
+  EXPECT_EQ(0xFFFFFFFFULL, findFirstSet(Z32));
+  EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findFirstSet(Z64));
+
+  uint8_t NZ8 = 42;
+  uint16_t NZ16 = 42;
+  uint32_t NZ32 = 42;
+  uint64_t NZ64 = 42;
+  EXPECT_EQ(1u, findFirstSet(NZ8));
+  EXPECT_EQ(1u, findFirstSet(NZ16));
+  EXPECT_EQ(1u, findFirstSet(NZ32));
+  EXPECT_EQ(1u, findFirstSet(NZ64));
+}
+
+TEST(MathExtras, findLastSet) {
+  uint8_t Z8 = 0;
+  uint16_t Z16 = 0;
+  uint32_t Z32 = 0;
+  uint64_t Z64 = 0;
+  EXPECT_EQ(0xFFULL, findLastSet(Z8));
+  EXPECT_EQ(0xFFFFULL, findLastSet(Z16));
+  EXPECT_EQ(0xFFFFFFFFULL, findLastSet(Z32));
+  EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findLastSet(Z64));
+
+  uint8_t NZ8 = 42;
+  uint16_t NZ16 = 42;
+  uint32_t NZ32 = 42;
+  uint64_t NZ64 = 42;
+  EXPECT_EQ(5u, findLastSet(NZ8));
+  EXPECT_EQ(5u, findLastSet(NZ16));
+  EXPECT_EQ(5u, findLastSet(NZ32));
+  EXPECT_EQ(5u, findLastSet(NZ64));
+}
+
+TEST(MathExtras, isIntN) {
+  EXPECT_TRUE(isIntN(16, 32767));
+  EXPECT_FALSE(isIntN(16, 32768));
+}
+
+TEST(MathExtras, isUIntN) {
+  EXPECT_TRUE(isUIntN(16, 65535));
+  EXPECT_FALSE(isUIntN(16, 65536));
+  EXPECT_TRUE(isUIntN(1, 0));
+  EXPECT_TRUE(isUIntN(6, 63));
+}
+
+TEST(MathExtras, maxIntN) {
+  EXPECT_EQ(32767, maxIntN(16));
+  EXPECT_EQ(2147483647, maxIntN(32));
+  EXPECT_EQ(std::numeric_limits<int32_t>::max(), maxIntN(32));
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), maxIntN(64));
+}
+
+TEST(MathExtras, minIntN) {
+  EXPECT_EQ(-32768LL, minIntN(16));
+  EXPECT_EQ(-64LL, minIntN(7));
+  EXPECT_EQ(std::numeric_limits<int32_t>::min(), minIntN(32));
+  EXPECT_EQ(std::numeric_limits<int64_t>::min(), minIntN(64));
+}
+
+TEST(MathExtras, maxUIntN) {
+  EXPECT_EQ(0xffffULL, maxUIntN(16));
+  EXPECT_EQ(0xffffffffULL, maxUIntN(32));
+  EXPECT_EQ(0xffffffffffffffffULL, maxUIntN(64));
+  EXPECT_EQ(1ULL, maxUIntN(1));
+  EXPECT_EQ(0x0fULL, maxUIntN(4));
+}
+
+TEST(MathExtras, reverseBits) {
+  uint8_t NZ8 = 42;
+  uint16_t NZ16 = 42;
+  uint32_t NZ32 = 42;
+  uint64_t NZ64 = 42;
+  EXPECT_EQ(0x54ULL, reverseBits(NZ8));
+  EXPECT_EQ(0x5400ULL, reverseBits(NZ16));
+  EXPECT_EQ(0x54000000ULL, reverseBits(NZ32));
+  EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64));
+}
+
+TEST(MathExtras, isPowerOf2_32) {
+  EXPECT_FALSE(isPowerOf2_32(0));
+  EXPECT_TRUE(isPowerOf2_32(1 << 6));
+  EXPECT_TRUE(isPowerOf2_32(1 << 12));
+  EXPECT_FALSE(isPowerOf2_32((1 << 19) + 3));
+  EXPECT_FALSE(isPowerOf2_32(0xABCDEF0));
+}
+
+TEST(MathExtras, isPowerOf2_64) {
+  EXPECT_FALSE(isPowerOf2_64(0));
+  EXPECT_TRUE(isPowerOf2_64(1LL << 46));
+  EXPECT_TRUE(isPowerOf2_64(1LL << 12));
+  EXPECT_FALSE(isPowerOf2_64((1LL << 53) + 3));
+  EXPECT_FALSE(isPowerOf2_64(0xABCDEF0ABCDEF0LL));
+}
+
+TEST(MathExtras, PowerOf2Ceil) {
+  EXPECT_EQ(0U, PowerOf2Ceil(0U));
+  EXPECT_EQ(8U, PowerOf2Ceil(8U));
+  EXPECT_EQ(8U, PowerOf2Ceil(7U));
+}
+
+TEST(MathExtras, PowerOf2Floor) {
+  EXPECT_EQ(0U, PowerOf2Floor(0U));
+  EXPECT_EQ(8U, PowerOf2Floor(8U));
+  EXPECT_EQ(4U, PowerOf2Floor(7U));
+}
+
+TEST(MathExtras, CTLog2) {
+  EXPECT_EQ(CTLog2<1ULL << 0>(), 0U);
+  EXPECT_EQ(CTLog2<1ULL << 1>(), 1U);
+  EXPECT_EQ(CTLog2<1ULL << 2>(), 2U);
+  EXPECT_EQ(CTLog2<1ULL << 3>(), 3U);
+  EXPECT_EQ(CTLog2<1ULL << 4>(), 4U);
+  EXPECT_EQ(CTLog2<1ULL << 5>(), 5U);
+  EXPECT_EQ(CTLog2<1ULL << 6>(), 6U);
+  EXPECT_EQ(CTLog2<1ULL << 7>(), 7U);
+  EXPECT_EQ(CTLog2<1ULL << 8>(), 8U);
+  EXPECT_EQ(CTLog2<1ULL << 9>(), 9U);
+  EXPECT_EQ(CTLog2<1ULL << 10>(), 10U);
+  EXPECT_EQ(CTLog2<1ULL << 11>(), 11U);
+  EXPECT_EQ(CTLog2<1ULL << 12>(), 12U);
+  EXPECT_EQ(CTLog2<1ULL << 13>(), 13U);
+  EXPECT_EQ(CTLog2<1ULL << 14>(), 14U);
+  EXPECT_EQ(CTLog2<1ULL << 15>(), 15U);
+}
+
+TEST(MathExtras, countLeadingOnes) {
+  for (int i = 30; i >= 0; --i) {
+    // Start with all ones and unset some bit.
+    EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
+  }
+  for (int i = 62; i >= 0; --i) {
+    // Start with all ones and unset some bit.
+    EXPECT_EQ(63u - i, countLeadingOnes(0xFFFFFFFFFFFFFFFFULL ^ (1LL << i)));
+  }
+  for (int i = 30; i >= 0; --i) {
+    // Start with all ones and unset some bit.
+    EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i)));
+  }
+}
+
+TEST(MathExtras, FloatBits) {
+  static const float kValue = 5632.34f;
+  EXPECT_FLOAT_EQ(kValue, BitsToFloat(FloatToBits(kValue)));
+}
+
+TEST(MathExtras, DoubleBits) {
+  static const double kValue = 87987234.983498;
+  EXPECT_DOUBLE_EQ(kValue, BitsToDouble(DoubleToBits(kValue)));
+}
+
+TEST(MathExtras, MinAlign) {
+  EXPECT_EQ(1u, MinAlign(2, 3));
+  EXPECT_EQ(2u, MinAlign(2, 4));
+  EXPECT_EQ(1u, MinAlign(17, 64));
+  EXPECT_EQ(256u, MinAlign(256, 512));
+}
+
+TEST(MathExtras, NextPowerOf2) {
+  EXPECT_EQ(4u, NextPowerOf2(3));
+  EXPECT_EQ(16u, NextPowerOf2(15));
+  EXPECT_EQ(256u, NextPowerOf2(128));
+}
+
+TEST(MathExtras, alignTo) {
+  EXPECT_EQ(8u, alignTo(5, 8));
+  EXPECT_EQ(24u, alignTo(17, 8));
+  EXPECT_EQ(0u, alignTo(~0LL, 8));
+
+  EXPECT_EQ(7u, alignTo(5, 8, 7));
+  EXPECT_EQ(17u, alignTo(17, 8, 1));
+  EXPECT_EQ(3u, alignTo(~0LL, 8, 3));
+  EXPECT_EQ(552u, alignTo(321, 255, 42));
+}
+
+template<typename T>
+void SaturatingAddTestHelper()
+{
+  const T Max = std::numeric_limits<T>::max();
+  bool ResultOverflowed;
+
+  EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2)));
+  EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingAdd(Max, T(1)));
+  EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1)));
+  EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingAdd(T(1), Max));
+  EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingAdd(Max, Max));
+  EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+}
+
+TEST(MathExtras, SaturatingAdd) {
+  SaturatingAddTestHelper<uint8_t>();
+  SaturatingAddTestHelper<uint16_t>();
+  SaturatingAddTestHelper<uint32_t>();
+  SaturatingAddTestHelper<uint64_t>();
+}
+
+template<typename T>
+void SaturatingMultiplyTestHelper()
+{
+  const T Max = std::numeric_limits<T>::max();
+  bool ResultOverflowed;
+
+  // Test basic multiplication.
+  EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3)));
+  EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2)));
+  EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  // Test multiplication by zero.
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  // Test multiplication by maximum value.
+  EXPECT_EQ(Max, SaturatingMultiply(Max, T(2)));
+  EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingMultiply(T(2), Max));
+  EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingMultiply(Max, Max));
+  EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  // Test interesting boundary conditions for algorithm -
+  // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1]
+  // and A + B == std::numeric_limits<T>::digits.
+  // We expect overflow iff A > B and K = 1.
+  const int Digits = std::numeric_limits<T>::digits;
+  for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) {
+    for (int K = -1; K <= 1; ++K) {
+      T X = (T(1) << A) - T(1);
+      T Y = (T(1) << B) + K;
+      bool OverflowExpected = A > B && K == 1;
+
+      if(OverflowExpected) {
+        EXPECT_EQ(Max, SaturatingMultiply(X, Y));
+        EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed));
+        EXPECT_TRUE(ResultOverflowed);
+      } else {
+        EXPECT_EQ(X * Y, SaturatingMultiply(X, Y));
+        EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed));
+        EXPECT_FALSE(ResultOverflowed);
+      }
+    }
+  }
+}
+
+TEST(MathExtras, SaturatingMultiply) {
+  SaturatingMultiplyTestHelper<uint8_t>();
+  SaturatingMultiplyTestHelper<uint16_t>();
+  SaturatingMultiplyTestHelper<uint32_t>();
+  SaturatingMultiplyTestHelper<uint64_t>();
+}
+
+template<typename T>
+void SaturatingMultiplyAddTestHelper()
+{
+  const T Max = std::numeric_limits<T>::max();
+  bool ResultOverflowed;
+
+  // Test basic multiply-add.
+  EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10)));
+  EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  // Test multiply overflows, add doesn't overflow
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  // Test multiply doesn't overflow, add overflows
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  // Test multiply-add with Max as operand
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed));
+  EXPECT_TRUE(ResultOverflowed);
+
+  // Test multiply-add with 0 as operand
+  EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+  EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed));
+  EXPECT_FALSE(ResultOverflowed);
+
+}
+
+TEST(MathExtras, SaturatingMultiplyAdd) {
+  SaturatingMultiplyAddTestHelper<uint8_t>();
+  SaturatingMultiplyAddTestHelper<uint16_t>();
+  SaturatingMultiplyAddTestHelper<uint32_t>();
+  SaturatingMultiplyAddTestHelper<uint64_t>();
+}
+
+TEST(MathExtras, IsShiftedUInt) {
+  EXPECT_TRUE((isShiftedUInt<1, 0>(0)));
+  EXPECT_TRUE((isShiftedUInt<1, 0>(1)));
+  EXPECT_FALSE((isShiftedUInt<1, 0>(2)));
+  EXPECT_FALSE((isShiftedUInt<1, 0>(3)));
+  EXPECT_FALSE((isShiftedUInt<1, 0>(0x8000000000000000)));
+  EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000)));
+  EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000)));
+  EXPECT_FALSE((isShiftedUInt<2, 62>(0xE000000000000000)));
+
+  // 0x201 is ten bits long and has a 1 in the MSB and LSB.
+  EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5)));
+  EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 4)));
+  EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 6)));
+}
+
+TEST(MathExtras, IsShiftedInt) {
+  EXPECT_TRUE((isShiftedInt<1, 0>(0)));
+  EXPECT_TRUE((isShiftedInt<1, 0>(-1)));
+  EXPECT_FALSE((isShiftedInt<1, 0>(2)));
+  EXPECT_FALSE((isShiftedInt<1, 0>(3)));
+  EXPECT_FALSE((isShiftedInt<1, 0>(0x8000000000000000)));
+  EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000)));
+  EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000)));
+  EXPECT_FALSE((isShiftedInt<2, 62>(0xE000000000000000)));
+
+  // 0x201 is ten bits long and has a 1 in the MSB and LSB.
+  EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5)));
+  EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 3)));
+  EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 6)));
+  EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5))));
+  EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 3))));
+  EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 6))));
+
+  EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15))));
+  EXPECT_FALSE((isShiftedInt<6, 10>(int64_t(1) << 15)));
+}
+
+template <typename T>
+class OverflowTest : public ::testing::Test { };
+
+using OverflowTestTypes = ::testing::Types<signed char, short, int, long,
+                                           long long>;
+
+TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes, );
+
+TYPED_TEST(OverflowTest, AddNoOverflow) {
+  TypeParam Result;
+  EXPECT_FALSE(AddOverflow<TypeParam>(1, 2, Result));
+  EXPECT_EQ(Result, TypeParam(3));
+}
+
+TYPED_TEST(OverflowTest, AddOverflowToNegative) {
+  TypeParam Result;
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result));
+  EXPECT_EQ(Result, TypeParam(-2));
+}
+
+TYPED_TEST(OverflowTest, AddOverflowToMin) {
+  TypeParam Result;
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result));
+  EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min());
+}
+
+TYPED_TEST(OverflowTest, AddOverflowToZero) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result));
+  EXPECT_EQ(Result, TypeParam(0));
+}
+
+TYPED_TEST(OverflowTest, AddOverflowToMax) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result));
+  EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max());
+}
+
+TYPED_TEST(OverflowTest, SubNoOverflow) {
+  TypeParam Result;
+  EXPECT_FALSE(SubOverflow<TypeParam>(1, 2, Result));
+  EXPECT_EQ(Result, TypeParam(-1));
+}
+
+TYPED_TEST(OverflowTest, SubOverflowToMax) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
+  EXPECT_EQ(Result, MinValue);
+}
+
+TYPED_TEST(OverflowTest, SubOverflowToMin) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result));
+  EXPECT_EQ(Result, MinValue);
+}
+
+TYPED_TEST(OverflowTest, SubOverflowToNegative) {
+  TypeParam Result;
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result));
+  EXPECT_EQ(Result, TypeParam(-1));
+}
+
+TYPED_TEST(OverflowTest, SubOverflowToPositive) {
+  TypeParam Result;
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result));
+  EXPECT_EQ(Result, TypeParam(1));
+}
+
+TYPED_TEST(OverflowTest, MulNoOverflow) {
+  TypeParam Result;
+  EXPECT_FALSE(MulOverflow<TypeParam>(1, 2, Result));
+  EXPECT_EQ(Result, 2);
+  EXPECT_FALSE(MulOverflow<TypeParam>(-1, 3, Result));
+  EXPECT_EQ(Result, -3);
+  EXPECT_FALSE(MulOverflow<TypeParam>(4, -2, Result));
+  EXPECT_EQ(Result, -8);
+  EXPECT_FALSE(MulOverflow<TypeParam>(-6, -5, Result));
+  EXPECT_EQ(Result, 30);
+}
+
+TYPED_TEST(OverflowTest, MulNoOverflowToMax) {
+  TypeParam Result;
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_FALSE(MulOverflow<TypeParam>(MinValue + 1, -1, Result));
+  EXPECT_EQ(Result, MaxValue);
+}
+
+TYPED_TEST(OverflowTest, MulOverflowToMin) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result));
+  EXPECT_EQ(Result, MinValue);
+}
+
+TYPED_TEST(OverflowTest, MulOverflowMax) {
+  TypeParam Result;
+  auto MinValue = std::numeric_limits<TypeParam>::min();
+  auto MaxValue = std::numeric_limits<TypeParam>::max();
+  EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result));
+  EXPECT_EQ(Result, 0);
+  EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result));
+  EXPECT_EQ(Result, 1);
+}
+
+TYPED_TEST(OverflowTest, MulResultZero) {
+  TypeParam Result;
+  EXPECT_FALSE(MulOverflow<TypeParam>(4, 0, Result));
+  EXPECT_EQ(Result, TypeParam(0));
+  EXPECT_FALSE(MulOverflow<TypeParam>(-5, 0, Result));
+  EXPECT_EQ(Result, TypeParam(0));
+  EXPECT_FALSE(MulOverflow<TypeParam>(0, 5, Result));
+  EXPECT_EQ(Result, TypeParam(0));
+  EXPECT_FALSE(MulOverflow<TypeParam>(0, -5, Result));
+  EXPECT_EQ(Result, TypeParam(0));
+}
+
+} // namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/PointerIntPairTest.cpp b/wpiutil/src/test/native/cpp/llvm/PointerIntPairTest.cpp
new file mode 100644
index 0000000..fcca5b6
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/PointerIntPairTest.cpp
@@ -0,0 +1,109 @@
+//===- llvm/unittest/ADT/PointerIntPairTest.cpp - Unit tests --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/PointerIntPair.h"
+#include "gtest/gtest.h"
+#include <limits>
+using namespace wpi;
+
+namespace {
+
+TEST(PointerIntPairTest, GetSet) {
+  struct S {
+    int i;
+  };
+  S s;
+
+  PointerIntPair<S *, 2> Pair(&s, 1U);
+  EXPECT_EQ(&s, Pair.getPointer());
+  EXPECT_EQ(1U, Pair.getInt());
+
+  Pair.setInt(2);
+  EXPECT_EQ(&s, Pair.getPointer());
+  EXPECT_EQ(2U, Pair.getInt());
+
+  Pair.setPointer(nullptr);
+  EXPECT_EQ(nullptr, Pair.getPointer());
+  EXPECT_EQ(2U, Pair.getInt());
+
+  Pair.setPointerAndInt(&s, 3U);
+  EXPECT_EQ(&s, Pair.getPointer());
+  EXPECT_EQ(3U, Pair.getInt());
+
+  // Make sure that we can perform all of our operations on enum classes.
+  //
+  // The concern is that enum classes are only explicitly convertible to
+  // integers. This means that if we assume in PointerIntPair this, a
+  // compilation error will result. This group of tests exercises the enum class
+  // code to make sure that we do not run into such issues in the future.
+  enum class E : unsigned {
+    Case1,
+    Case2,
+    Case3,
+  };
+  PointerIntPair<S *, 2, E> Pair2(&s, E::Case1);
+  EXPECT_EQ(&s, Pair2.getPointer());
+  EXPECT_EQ(E::Case1, Pair2.getInt());
+
+  Pair2.setInt(E::Case2);
+  EXPECT_EQ(&s, Pair2.getPointer());
+  EXPECT_EQ(E::Case2, Pair2.getInt());
+
+  Pair2.setPointer(nullptr);
+  EXPECT_EQ(nullptr, Pair2.getPointer());
+  EXPECT_EQ(E::Case2, Pair2.getInt());
+
+  Pair2.setPointerAndInt(&s, E::Case3);
+  EXPECT_EQ(&s, Pair2.getPointer());
+  EXPECT_EQ(E::Case3, Pair2.getInt());
+
+  static_assert(std::is_trivially_copyable<PointerIntPair<S *, 2, E>>::value,
+                "trivially copyable");
+}
+
+TEST(PointerIntPairTest, DefaultInitialize) {
+  PointerIntPair<float *, 2> Pair;
+  EXPECT_EQ(nullptr, Pair.getPointer());
+  EXPECT_EQ(0U, Pair.getInt());
+}
+
+// In real code this would be a word-sized integer limited to 31 bits.
+struct Fixnum31 {
+  uintptr_t Value;
+};
+struct FixnumPointerTraits {
+  static inline void *getAsVoidPointer(Fixnum31 Num) {
+    return reinterpret_cast<void *>(Num.Value << NumLowBitsAvailable);
+  }
+  static inline Fixnum31 getFromVoidPointer(void *P) {
+    // In real code this would assert that the value is in range.
+    return {reinterpret_cast<uintptr_t>(P) >> NumLowBitsAvailable};
+  }
+  static constexpr int NumLowBitsAvailable =
+      std::numeric_limits<uintptr_t>::digits - 31;
+};
+TEST(PointerIntPairTest, ManyUnusedBits) {
+
+  PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits> pair;
+  EXPECT_EQ((uintptr_t)0, pair.getPointer().Value);
+  EXPECT_FALSE(pair.getInt());
+
+  pair.setPointerAndInt({ 0x7FFFFFFF }, true );
+  EXPECT_EQ((uintptr_t)0x7FFFFFFF, pair.getPointer().Value);
+  EXPECT_TRUE(pair.getInt());
+
+  EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
+            (int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
+
+  static_assert(
+      std::is_trivially_copyable<
+          PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>::value,
+      "trivially copyable");
+}
+
+} // end anonymous namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/PointerUnionTest.cpp b/wpiutil/src/test/native/cpp/llvm/PointerUnionTest.cpp
new file mode 100644
index 0000000..5a94a45
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/PointerUnionTest.cpp
@@ -0,0 +1,159 @@
+//===- llvm/unittest/ADT/PointerUnionTest.cpp - Optional unit tests -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/PointerUnion.h"
+#include "gtest/gtest.h"
+using namespace wpi;
+
+namespace {
+
+typedef PointerUnion<int *, float *> PU;
+typedef PointerUnion<int *, float *, long long *> PU3;
+typedef PointerUnion<int *, float *, long long *, double *> PU4;
+
+struct PointerUnionTest : public testing::Test {
+  float f;
+  int i;
+  double d;
+  long long l;
+
+  PU a, b, c, n;
+  PU3 i3, f3, l3;
+  PU4 i4, f4, l4, d4;
+  PU4 i4null, f4null, l4null, d4null;
+
+  PointerUnionTest()
+      : f(3.14f), i(42), d(3.14), l(42), a(&f), b(&i), c(&i), n(), i3(&i),
+        f3(&f), l3(&l), i4(&i), f4(&f), l4(&l), d4(&d), i4null((int *)nullptr),
+        f4null((float *)nullptr), l4null((long long *)nullptr),
+        d4null((double *)nullptr) {}
+};
+
+TEST_F(PointerUnionTest, Comparison) {
+  EXPECT_TRUE(a == a);
+  EXPECT_FALSE(a != a);
+  EXPECT_TRUE(a != b);
+  EXPECT_FALSE(a == b);
+  EXPECT_TRUE(b == c);
+  EXPECT_FALSE(b != c);
+  EXPECT_TRUE(b != n);
+  EXPECT_FALSE(b == n);
+  EXPECT_TRUE(i3 == i3);
+  EXPECT_FALSE(i3 != i3);
+  EXPECT_TRUE(i3 != f3);
+  EXPECT_TRUE(f3 != l3);
+  EXPECT_TRUE(i4 == i4);
+  EXPECT_FALSE(i4 != i4);
+  EXPECT_TRUE(i4 != f4);
+  EXPECT_TRUE(i4 != l4);
+  EXPECT_TRUE(f4 != l4);
+  EXPECT_TRUE(l4 != d4);
+  EXPECT_TRUE(i4null != f4null);
+  EXPECT_TRUE(i4null != l4null);
+  EXPECT_TRUE(i4null != d4null);
+}
+
+TEST_F(PointerUnionTest, Null) {
+  EXPECT_FALSE(a.isNull());
+  EXPECT_FALSE(b.isNull());
+  EXPECT_TRUE(n.isNull());
+  EXPECT_FALSE(!a);
+  EXPECT_FALSE(!b);
+  EXPECT_TRUE(!n);
+  // workaround an issue with EXPECT macros and explicit bool
+  EXPECT_TRUE((bool)a);
+  EXPECT_TRUE((bool)b);
+  EXPECT_FALSE(n);
+
+  EXPECT_NE(n, b);
+  EXPECT_EQ(b, c);
+  b = nullptr;
+  EXPECT_EQ(n, b);
+  EXPECT_NE(b, c);
+  EXPECT_FALSE(i3.isNull());
+  EXPECT_FALSE(f3.isNull());
+  EXPECT_FALSE(l3.isNull());
+  EXPECT_FALSE(i4.isNull());
+  EXPECT_FALSE(f4.isNull());
+  EXPECT_FALSE(l4.isNull());
+  EXPECT_FALSE(d4.isNull());
+  EXPECT_TRUE(i4null.isNull());
+  EXPECT_TRUE(f4null.isNull());
+  EXPECT_TRUE(l4null.isNull());
+  EXPECT_TRUE(d4null.isNull());
+}
+
+TEST_F(PointerUnionTest, Is) {
+  EXPECT_FALSE(a.is<int *>());
+  EXPECT_TRUE(a.is<float *>());
+  EXPECT_TRUE(b.is<int *>());
+  EXPECT_FALSE(b.is<float *>());
+  EXPECT_TRUE(n.is<int *>());
+  EXPECT_FALSE(n.is<float *>());
+  EXPECT_TRUE(i3.is<int *>());
+  EXPECT_TRUE(f3.is<float *>());
+  EXPECT_TRUE(l3.is<long long *>());
+  EXPECT_TRUE(i4.is<int *>());
+  EXPECT_TRUE(f4.is<float *>());
+  EXPECT_TRUE(l4.is<long long *>());
+  EXPECT_TRUE(d4.is<double *>());
+  EXPECT_TRUE(i4null.is<int *>());
+  EXPECT_TRUE(f4null.is<float *>());
+  EXPECT_TRUE(l4null.is<long long *>());
+  EXPECT_TRUE(d4null.is<double *>());
+}
+
+TEST_F(PointerUnionTest, Get) {
+  EXPECT_EQ(a.get<float *>(), &f);
+  EXPECT_EQ(b.get<int *>(), &i);
+  EXPECT_EQ(n.get<int *>(), (int *)nullptr);
+}
+
+template<int I> struct alignas(8) Aligned {};
+
+typedef PointerUnion<Aligned<0> *, Aligned<1> *, Aligned<2> *, Aligned<3> *,
+                     Aligned<4> *, Aligned<5> *, Aligned<6> *, Aligned<7> *>
+    PU8;
+
+TEST_F(PointerUnionTest, ManyElements) {
+  Aligned<0> a0;
+  Aligned<7> a7;
+
+  PU8 a = &a0;
+  EXPECT_TRUE(a.is<Aligned<0>*>());
+  EXPECT_FALSE(a.is<Aligned<1>*>());
+  EXPECT_FALSE(a.is<Aligned<2>*>());
+  EXPECT_FALSE(a.is<Aligned<3>*>());
+  EXPECT_FALSE(a.is<Aligned<4>*>());
+  EXPECT_FALSE(a.is<Aligned<5>*>());
+  EXPECT_FALSE(a.is<Aligned<6>*>());
+  EXPECT_FALSE(a.is<Aligned<7>*>());
+  EXPECT_EQ(a.dyn_cast<Aligned<0>*>(), &a0);
+  EXPECT_EQ(*a.getAddrOfPtr1(), &a0);
+
+  a = &a7;
+  EXPECT_FALSE(a.is<Aligned<0>*>());
+  EXPECT_FALSE(a.is<Aligned<1>*>());
+  EXPECT_FALSE(a.is<Aligned<2>*>());
+  EXPECT_FALSE(a.is<Aligned<3>*>());
+  EXPECT_FALSE(a.is<Aligned<4>*>());
+  EXPECT_FALSE(a.is<Aligned<5>*>());
+  EXPECT_FALSE(a.is<Aligned<6>*>());
+  EXPECT_TRUE(a.is<Aligned<7>*>());
+  EXPECT_EQ(a.dyn_cast<Aligned<7>*>(), &a7);
+
+  EXPECT_TRUE(a == PU8(&a7));
+  EXPECT_TRUE(a != PU8(&a0));
+}
+
+TEST_F(PointerUnionTest, GetAddrOfPtr1) {
+  EXPECT_TRUE((void *)b.getAddrOfPtr1() == (void *)&b);
+  EXPECT_TRUE((void *)n.getAddrOfPtr1() == (void *)&n);
+}
+
+} // end anonymous namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/STLForwardCompatTest.cpp b/wpiutil/src/test/native/cpp/llvm/STLForwardCompatTest.cpp
new file mode 100644
index 0000000..333359e
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/STLForwardCompatTest.cpp
@@ -0,0 +1,78 @@
+//===- STLForwardCompatTest.cpp - Unit tests for STLForwardCompat ---------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/STLForwardCompat.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(STLForwardCompatTest, NegationTest) {
+  EXPECT_TRUE((wpi::negation<std::false_type>::value));
+  EXPECT_FALSE((wpi::negation<std::true_type>::value));
+}
+
+struct incomplete_type;
+
+TEST(STLForwardCompatTest, ConjunctionTest) {
+  EXPECT_TRUE((wpi::conjunction<>::value));
+  EXPECT_FALSE((wpi::conjunction<std::false_type>::value));
+  EXPECT_TRUE((wpi::conjunction<std::true_type>::value));
+  EXPECT_FALSE((wpi::conjunction<std::false_type, incomplete_type>::value));
+  EXPECT_FALSE((wpi::conjunction<std::false_type, std::true_type>::value));
+  EXPECT_FALSE((wpi::conjunction<std::true_type, std::false_type>::value));
+  EXPECT_TRUE((wpi::conjunction<std::true_type, std::true_type>::value));
+  EXPECT_TRUE((wpi::conjunction<std::true_type, std::true_type,
+                                 std::true_type>::value));
+}
+
+TEST(STLForwardCompatTest, DisjunctionTest) {
+  EXPECT_FALSE((wpi::disjunction<>::value));
+  EXPECT_FALSE((wpi::disjunction<std::false_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::true_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::true_type, incomplete_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::false_type, std::true_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::true_type, std::false_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::true_type, std::true_type>::value));
+  EXPECT_TRUE((wpi::disjunction<std::true_type, std::true_type,
+                                 std::true_type>::value));
+}
+
+template <typename T>
+class STLForwardCompatRemoveCVRefTest : public ::testing::Test {};
+
+using STLForwardCompatRemoveCVRefTestTypes = ::testing::Types<
+    // clang-format off
+    std::pair<int, int>,
+    std::pair<int &, int>,
+    std::pair<const int, int>,
+    std::pair<volatile int, int>,
+    std::pair<const volatile int &, int>,
+    std::pair<int *, int *>,
+    std::pair<int *const, int *>,
+    std::pair<const int *, const int *>,
+    std::pair<int *&, int *>
+    // clang-format on
+    >;
+
+TYPED_TEST_SUITE(STLForwardCompatRemoveCVRefTest,
+                 STLForwardCompatRemoveCVRefTestTypes, );
+
+TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRef) {
+  using From = typename TypeParam::first_type;
+  using To = typename TypeParam::second_type;
+  EXPECT_TRUE(
+      (std::is_same<typename wpi::remove_cvref<From>::type, To>::value));
+}
+
+TYPED_TEST(STLForwardCompatRemoveCVRefTest, RemoveCVRefT) {
+  using From = typename TypeParam::first_type;
+  EXPECT_TRUE((std::is_same<typename wpi::remove_cvref<From>::type,
+                            wpi::remove_cvref_t<From>>::value));
+}
+
+} // namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/SmallPtrSetTest.cpp b/wpiutil/src/test/native/cpp/llvm/SmallPtrSetTest.cpp
new file mode 100644
index 0000000..1916d50
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/SmallPtrSetTest.cpp
@@ -0,0 +1,412 @@
+//===- llvm/unittest/ADT/SmallPtrSetTest.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// SmallPtrSet unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SmallPtrSet.h"
+#include "wpi/PointerIntPair.h"
+#include "wpi/PointerLikeTypeTraits.h"
+#include "gtest/gtest.h"
+
+#include <algorithm>
+
+using namespace wpi;
+
+TEST(SmallPtrSetTest, Assignment) {
+  int buf[8];
+  for (int i = 0; i < 8; ++i)
+    buf[i] = 0;
+
+  SmallPtrSet<int *, 4> s1 = {&buf[0], &buf[1]};
+  SmallPtrSet<int *, 4> s2;
+  (s2 = s1).insert(&buf[2]);
+
+  // Self assign as well.
+  (s2 = static_cast<SmallPtrSet<int *, 4> &>(s2)).insert(&buf[3]);
+
+  s1 = s2;
+  EXPECT_EQ(4U, s1.size());
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_TRUE(s1.count(&buf[i]));
+    else
+      EXPECT_FALSE(s1.count(&buf[i]));
+
+  // Assign and insert with initializer lists, and ones that contain both
+  // duplicates and out-of-order elements.
+  (s2 = {&buf[6], &buf[7], &buf[6]}).insert({&buf[5], &buf[4]});
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_FALSE(s2.count(&buf[i]));
+    else
+      EXPECT_TRUE(s2.count(&buf[i]));
+}
+
+TEST(SmallPtrSetTest, GrowthTest) {
+  int i;
+  int buf[8];
+  for(i=0; i<8; ++i) buf[i]=0;
+
+
+  SmallPtrSet<int *, 4> s;
+  typedef SmallPtrSet<int *, 4>::iterator iter;
+
+  s.insert(&buf[0]);
+  s.insert(&buf[1]);
+  s.insert(&buf[2]);
+  s.insert(&buf[3]);
+  EXPECT_EQ(4U, s.size());
+
+  i = 0;
+  for(iter I=s.begin(), E=s.end(); I!=E; ++I, ++i)
+      (**I)++;
+  EXPECT_EQ(4, i);
+  for(i=0; i<8; ++i)
+      EXPECT_EQ(i<4?1:0,buf[i]);
+
+  s.insert(&buf[4]);
+  s.insert(&buf[5]);
+  s.insert(&buf[6]);
+  s.insert(&buf[7]);
+
+  i = 0;
+  for(iter I=s.begin(), E=s.end(); I!=E; ++I, ++i)
+      (**I)++;
+  EXPECT_EQ(8, i);
+  s.erase(&buf[4]);
+  s.erase(&buf[5]);
+  s.erase(&buf[6]);
+  s.erase(&buf[7]);
+  EXPECT_EQ(4U, s.size());
+
+  i = 0;
+  for(iter I=s.begin(), E=s.end(); I!=E; ++I, ++i)
+      (**I)++;
+  EXPECT_EQ(4, i);
+  for(i=0; i<8; ++i)
+      EXPECT_EQ(i<4?3:1,buf[i]);
+
+  s.clear();
+  for(i=0; i<8; ++i) buf[i]=0;
+  for(i=0; i<128; ++i) s.insert(&buf[i%8]); // test repeated entires
+  EXPECT_EQ(8U, s.size());
+  for(iter I=s.begin(), E=s.end(); I!=E; ++I, ++i)
+      (**I)++;
+  for(i=0; i<8; ++i)
+      EXPECT_EQ(1,buf[i]);
+}
+
+TEST(SmallPtrSetTest, CopyAndMoveTest) {
+  int buf[8];
+  for (int i = 0; i < 8; ++i)
+    buf[i] = 0;
+
+  SmallPtrSet<int *, 4> s1;
+  s1.insert(&buf[0]);
+  s1.insert(&buf[1]);
+  s1.insert(&buf[2]);
+  s1.insert(&buf[3]);
+  EXPECT_EQ(4U, s1.size());
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_TRUE(s1.count(&buf[i]));
+    else
+      EXPECT_FALSE(s1.count(&buf[i]));
+
+  SmallPtrSet<int *, 4> s2(s1);
+  EXPECT_EQ(4U, s2.size());
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_TRUE(s2.count(&buf[i]));
+    else
+      EXPECT_FALSE(s2.count(&buf[i]));
+
+  s1 = s2;
+  EXPECT_EQ(4U, s1.size());
+  EXPECT_EQ(4U, s2.size());
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_TRUE(s1.count(&buf[i]));
+    else
+      EXPECT_FALSE(s1.count(&buf[i]));
+
+  SmallPtrSet<int *, 4> s3(std::move(s1));
+  EXPECT_EQ(4U, s3.size());
+  EXPECT_TRUE(s1.empty());
+  for (int i = 0; i < 8; ++i)
+    if (i < 4)
+      EXPECT_TRUE(s3.count(&buf[i]));
+    else
+      EXPECT_FALSE(s3.count(&buf[i]));
+
+  // Move assign into the moved-from object. Also test move of a non-small
+  // container.
+  s3.insert(&buf[4]);
+  s3.insert(&buf[5]);
+  s3.insert(&buf[6]);
+  s3.insert(&buf[7]);
+  s1 = std::move(s3);
+  EXPECT_EQ(8U, s1.size());
+  EXPECT_TRUE(s3.empty());
+  for (int i = 0; i < 8; ++i)
+    EXPECT_TRUE(s1.count(&buf[i]));
+
+  // Copy assign into a moved-from object.
+  s3 = s1;
+  EXPECT_EQ(8U, s3.size());
+  EXPECT_EQ(8U, s1.size());
+  for (int i = 0; i < 8; ++i)
+    EXPECT_TRUE(s3.count(&buf[i]));
+}
+
+TEST(SmallPtrSetTest, SwapTest) {
+  int buf[10];
+
+  SmallPtrSet<int *, 2> a;
+  SmallPtrSet<int *, 2> b;
+
+  a.insert(&buf[0]);
+  a.insert(&buf[1]);
+  b.insert(&buf[2]);
+
+  EXPECT_EQ(2U, a.size());
+  EXPECT_EQ(1U, b.size());
+  EXPECT_TRUE(a.count(&buf[0]));
+  EXPECT_TRUE(a.count(&buf[1]));
+  EXPECT_FALSE(a.count(&buf[2]));
+  EXPECT_FALSE(a.count(&buf[3]));
+  EXPECT_FALSE(b.count(&buf[0]));
+  EXPECT_FALSE(b.count(&buf[1]));
+  EXPECT_TRUE(b.count(&buf[2]));
+  EXPECT_FALSE(b.count(&buf[3]));
+
+  std::swap(a, b);
+
+  EXPECT_EQ(1U, a.size());
+  EXPECT_EQ(2U, b.size());
+  EXPECT_FALSE(a.count(&buf[0]));
+  EXPECT_FALSE(a.count(&buf[1]));
+  EXPECT_TRUE(a.count(&buf[2]));
+  EXPECT_FALSE(a.count(&buf[3]));
+  EXPECT_TRUE(b.count(&buf[0]));
+  EXPECT_TRUE(b.count(&buf[1]));
+  EXPECT_FALSE(b.count(&buf[2]));
+  EXPECT_FALSE(b.count(&buf[3]));
+
+  b.insert(&buf[3]);
+  std::swap(a, b);
+
+  EXPECT_EQ(3U, a.size());
+  EXPECT_EQ(1U, b.size());
+  EXPECT_TRUE(a.count(&buf[0]));
+  EXPECT_TRUE(a.count(&buf[1]));
+  EXPECT_FALSE(a.count(&buf[2]));
+  EXPECT_TRUE(a.count(&buf[3]));
+  EXPECT_FALSE(b.count(&buf[0]));
+  EXPECT_FALSE(b.count(&buf[1]));
+  EXPECT_TRUE(b.count(&buf[2]));
+  EXPECT_FALSE(b.count(&buf[3]));
+
+  std::swap(a, b);
+
+  EXPECT_EQ(1U, a.size());
+  EXPECT_EQ(3U, b.size());
+  EXPECT_FALSE(a.count(&buf[0]));
+  EXPECT_FALSE(a.count(&buf[1]));
+  EXPECT_TRUE(a.count(&buf[2]));
+  EXPECT_FALSE(a.count(&buf[3]));
+  EXPECT_TRUE(b.count(&buf[0]));
+  EXPECT_TRUE(b.count(&buf[1]));
+  EXPECT_FALSE(b.count(&buf[2]));
+  EXPECT_TRUE(b.count(&buf[3]));
+
+  a.insert(&buf[4]);
+  a.insert(&buf[5]);
+  a.insert(&buf[6]);
+
+  std::swap(b, a);
+
+  EXPECT_EQ(3U, a.size());
+  EXPECT_EQ(4U, b.size());
+  EXPECT_TRUE(b.count(&buf[2]));
+  EXPECT_TRUE(b.count(&buf[4]));
+  EXPECT_TRUE(b.count(&buf[5]));
+  EXPECT_TRUE(b.count(&buf[6]));
+  EXPECT_TRUE(a.count(&buf[0]));
+  EXPECT_TRUE(a.count(&buf[1]));
+  EXPECT_TRUE(a.count(&buf[3]));
+}
+
+void checkEraseAndIterators(SmallPtrSetImpl<int*> &S) {
+  int buf[3];
+
+  S.insert(&buf[0]);
+  S.insert(&buf[1]);
+  S.insert(&buf[2]);
+
+  // Iterators must still be valid after erase() calls;
+  auto B = S.begin();
+  auto M = std::next(B);
+  auto E = S.end();
+  EXPECT_TRUE(*B == &buf[0] || *B == &buf[1] || *B == &buf[2]);
+  EXPECT_TRUE(*M == &buf[0] || *M == &buf[1] || *M == &buf[2]);
+  EXPECT_TRUE(*B != *M);
+  int *Removable = *std::next(M);
+  // No iterator points to Removable now.
+  EXPECT_TRUE(Removable == &buf[0] || Removable == &buf[1] ||
+              Removable == &buf[2]);
+  EXPECT_TRUE(Removable != *B && Removable != *M);
+
+  S.erase(Removable);
+
+  // B,M,E iterators should still be valid
+  EXPECT_EQ(B, S.begin());
+  EXPECT_EQ(M, std::next(B));
+  EXPECT_EQ(E, S.end());
+  EXPECT_EQ(std::next(M), E);
+}
+
+TEST(SmallPtrSetTest, EraseTest) {
+  // Test when set stays small.
+  SmallPtrSet<int *, 8> B;
+  checkEraseAndIterators(B);
+
+  // Test when set grows big.
+  SmallPtrSet<int *, 2> A;
+  checkEraseAndIterators(A);
+}
+
+// Verify that dereferencing and iteration work.
+TEST(SmallPtrSetTest, dereferenceAndIterate) {
+  int Ints[] = {0, 1, 2, 3, 4, 5, 6, 7};
+  SmallPtrSet<const int *, 4> S;
+  for (int &I : Ints) {
+    EXPECT_EQ(&I, *S.insert(&I).first);
+    EXPECT_EQ(&I, *S.find(&I));
+  }
+
+  // Iterate from each and count how many times each element is found.
+  int Found[sizeof(Ints)/sizeof(int)] = {0};
+  for (int &I : Ints)
+    for (auto F = S.find(&I), E = S.end(); F != E; ++F)
+      ++Found[*F - Ints];
+
+  // Sort.  We should hit the first element just once and the final element N
+  // times.
+  std::sort(std::begin(Found), std::end(Found));
+  for (auto F = std::begin(Found), E = std::end(Found); F != E; ++F)
+    EXPECT_EQ(F - Found + 1, *F);
+}
+
+// Verify that const pointers work for count and find even when the underlying
+// SmallPtrSet is not for a const pointer type.
+TEST(SmallPtrSetTest, ConstTest) {
+  SmallPtrSet<int *, 8> IntSet;
+  int A;
+  int *B = &A;
+  const int *C = &A;
+  IntSet.insert(B);
+  EXPECT_EQ(IntSet.count(B), 1u);
+  EXPECT_EQ(IntSet.count(C), 1u);
+  EXPECT_TRUE(IntSet.contains(B));
+  EXPECT_TRUE(IntSet.contains(C));
+}
+
+// Verify that we automatically get the const version of PointerLikeTypeTraits
+// filled in for us, even for a non-pointer type
+using TestPair = PointerIntPair<int *, 1>;
+
+TEST(SmallPtrSetTest, ConstNonPtrTest) {
+  SmallPtrSet<TestPair, 8> IntSet;
+  int A[1];
+  TestPair Pair(&A[0], 1);
+  IntSet.insert(Pair);
+  EXPECT_EQ(IntSet.count(Pair), 1u);
+  EXPECT_TRUE(IntSet.contains(Pair));
+}
+
+// Test equality comparison.
+TEST(SmallPtrSetTest, EqualityComparison) {
+  int buf[3];
+  for (int i = 0; i < 3; ++i)
+    buf[i] = 0;
+
+  SmallPtrSet<int *, 1> a;
+  a.insert(&buf[0]);
+  a.insert(&buf[1]);
+
+  SmallPtrSet<int *, 2> b;
+  b.insert(&buf[1]);
+  b.insert(&buf[0]);
+
+  SmallPtrSet<int *, 3> c;
+  c.insert(&buf[1]);
+  c.insert(&buf[2]);
+
+  SmallPtrSet<int *, 4> d;
+  d.insert(&buf[0]);
+
+  SmallPtrSet<int *, 5> e;
+  e.insert(&buf[0]);
+  e.insert(&buf[1]);
+  e.insert(&buf[2]);
+
+  EXPECT_EQ(a, b);
+  EXPECT_EQ(b, a);
+  EXPECT_NE(b, c);
+  EXPECT_NE(c, a);
+  EXPECT_NE(d, a);
+  EXPECT_NE(a, d);
+  EXPECT_NE(a, e);
+  EXPECT_NE(e, a);
+  EXPECT_NE(c, e);
+  EXPECT_NE(e, d);
+}
+
+TEST(SmallPtrSetTest, Contains) {
+  SmallPtrSet<int *, 2> Set;
+  int buf[4] = {0, 11, 22, 11};
+  EXPECT_FALSE(Set.contains(&buf[0]));
+  EXPECT_FALSE(Set.contains(&buf[1]));
+
+  Set.insert(&buf[0]);
+  Set.insert(&buf[1]);
+  EXPECT_TRUE(Set.contains(&buf[0]));
+  EXPECT_TRUE(Set.contains(&buf[1]));
+  EXPECT_FALSE(Set.contains(&buf[3]));
+
+  Set.insert(&buf[1]);
+  EXPECT_TRUE(Set.contains(&buf[0]));
+  EXPECT_TRUE(Set.contains(&buf[1]));
+  EXPECT_FALSE(Set.contains(&buf[3]));
+
+  Set.erase(&buf[1]);
+  EXPECT_TRUE(Set.contains(&buf[0]));
+  EXPECT_FALSE(Set.contains(&buf[1]));
+
+  Set.insert(&buf[1]);
+  Set.insert(&buf[2]);
+  EXPECT_TRUE(Set.contains(&buf[0]));
+  EXPECT_TRUE(Set.contains(&buf[1]));
+  EXPECT_TRUE(Set.contains(&buf[2]));
+}
+
+TEST(SmallPtrSetTest, InsertIterator) {
+  SmallPtrSet<int *, 5> Set;
+  int Vals[5] = {11, 22, 33, 44, 55};
+  int *Buf[5] = {&Vals[0], &Vals[1], &Vals[2], &Vals[3], &Vals[4]};
+
+  for (int *Ptr : Buf)
+    Set.insert(Set.begin(), Ptr);
+
+  // Ensure that all of the values were copied into the set.
+  for (const auto *Ptr : Buf)
+    EXPECT_TRUE(Set.contains(Ptr));
+}
diff --git a/wpiutil/src/test/native/cpp/llvm/SmallSetTest.cpp b/wpiutil/src/test/native/cpp/llvm/SmallSetTest.cpp
new file mode 100644
index 0000000..e245aa4
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/SmallSetTest.cpp
@@ -0,0 +1,194 @@
+//===- llvm/unittest/ADT/SmallSetTest.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// SmallSet unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SmallSet.h"
+#include "gtest/gtest.h"
+#include <string>
+
+using namespace wpi;
+
+TEST(SmallSetTest, Insert) {
+
+  SmallSet<int, 4> s1;
+
+  for (int i = 0; i < 4; i++)
+    s1.insert(i);
+
+  for (int i = 0; i < 4; i++)
+    s1.insert(i);
+
+  EXPECT_EQ(4u, s1.size());
+
+  for (int i = 0; i < 4; i++)
+    EXPECT_EQ(1u, s1.count(i));
+
+  EXPECT_EQ(0u, s1.count(4));
+}
+
+TEST(SmallSetTest, Grow) {
+  SmallSet<int, 4> s1;
+
+  for (int i = 0; i < 8; i++)
+    s1.insert(i);
+
+  EXPECT_EQ(8u, s1.size());
+
+  for (int i = 0; i < 8; i++)
+    EXPECT_EQ(1u, s1.count(i));
+
+  EXPECT_EQ(0u, s1.count(8));
+}
+
+TEST(SmallSetTest, Erase) {
+  SmallSet<int, 4> s1;
+
+  for (int i = 0; i < 8; i++)
+    s1.insert(i);
+
+  EXPECT_EQ(8u, s1.size());
+
+  // Remove elements one by one and check if all other elements are still there.
+  for (int i = 0; i < 8; i++) {
+    EXPECT_EQ(1u, s1.count(i));
+    EXPECT_TRUE(s1.erase(i));
+    EXPECT_EQ(0u, s1.count(i));
+    EXPECT_EQ(8u - i - 1, s1.size());
+    for (int j = i + 1; j < 8; j++)
+      EXPECT_EQ(1u, s1.count(j));
+  }
+
+  EXPECT_EQ(0u, s1.count(8));
+}
+
+TEST(SmallSetTest, IteratorInt) {
+  SmallSet<int, 4> s1;
+
+  // Test the 'small' case.
+  for (int i = 0; i < 3; i++)
+    s1.insert(i);
+
+  std::vector<int> V(s1.begin(), s1.end());
+  // Make sure the elements are in the expected order.
+  std::sort(V.begin(), V.end());
+  for (int i = 0; i < 3; i++)
+    EXPECT_EQ(i, V[i]);
+
+  // Test the 'big' case by adding a few more elements to switch to std::set
+  // internally.
+  for (int i = 3; i < 6; i++)
+    s1.insert(i);
+
+  V.assign(s1.begin(), s1.end());
+  // Make sure the elements are in the expected order.
+  std::sort(V.begin(), V.end());
+  for (int i = 0; i < 6; i++)
+    EXPECT_EQ(i, V[i]);
+}
+
+TEST(SmallSetTest, IteratorString) {
+  // Test SmallSetIterator for SmallSet with a type with non-trivial
+  // ctors/dtors.
+  SmallSet<std::string, 2> s1;
+
+  s1.insert("str 1");
+  s1.insert("str 2");
+  s1.insert("str 1");
+
+  std::vector<std::string> V(s1.begin(), s1.end());
+  std::sort(V.begin(), V.end());
+  EXPECT_EQ(2u, s1.size());
+  EXPECT_EQ("str 1", V[0]);
+  EXPECT_EQ("str 2", V[1]);
+
+  s1.insert("str 4");
+  s1.insert("str 0");
+  s1.insert("str 4");
+
+  V.assign(s1.begin(), s1.end());
+  // Make sure the elements are in the expected order.
+  std::sort(V.begin(), V.end());
+  EXPECT_EQ(4u, s1.size());
+  EXPECT_EQ("str 0", V[0]);
+  EXPECT_EQ("str 1", V[1]);
+  EXPECT_EQ("str 2", V[2]);
+  EXPECT_EQ("str 4", V[3]);
+}
+
+TEST(SmallSetTest, IteratorIncMoveCopy) {
+  // Test SmallSetIterator for SmallSet with a type with non-trivial
+  // ctors/dtors.
+  SmallSet<std::string, 2> s1;
+
+  s1.insert("str 1");
+  s1.insert("str 2");
+
+  auto Iter = s1.begin();
+  EXPECT_EQ("str 1", *Iter);
+  ++Iter;
+  EXPECT_EQ("str 2", *Iter);
+
+  s1.insert("str 4");
+  s1.insert("str 0");
+  auto Iter2 = s1.begin();
+  Iter = std::move(Iter2);
+  EXPECT_EQ("str 0", *Iter);
+}
+
+TEST(SmallSetTest, EqualityComparisonTest) {
+  SmallSet<int, 8> s1small;
+  SmallSet<int, 10> s2small;
+  SmallSet<int, 3> s3large;
+  SmallSet<int, 8> s4large;
+
+  for (int i = 1; i < 5; i++) {
+    s1small.insert(i);
+    s2small.insert(5 - i);
+    s3large.insert(i);
+  }
+  for (int i = 1; i < 11; i++)
+    s4large.insert(i);
+
+  EXPECT_EQ(s1small, s1small);
+  EXPECT_EQ(s3large, s3large);
+
+  EXPECT_EQ(s1small, s2small);
+  EXPECT_EQ(s1small, s3large);
+  EXPECT_EQ(s2small, s3large);
+
+  EXPECT_NE(s1small, s4large);
+  EXPECT_NE(s4large, s3large);
+}
+
+TEST(SmallSetTest, Contains) {
+  SmallSet<int, 2> Set;
+  EXPECT_FALSE(Set.contains(0));
+  EXPECT_FALSE(Set.contains(1));
+
+  Set.insert(0);
+  Set.insert(1);
+  EXPECT_TRUE(Set.contains(0));
+  EXPECT_TRUE(Set.contains(1));
+
+  Set.insert(1);
+  EXPECT_TRUE(Set.contains(0));
+  EXPECT_TRUE(Set.contains(1));
+
+  Set.erase(1);
+  EXPECT_TRUE(Set.contains(0));
+  EXPECT_FALSE(Set.contains(1));
+
+  Set.insert(1);
+  Set.insert(2);
+  EXPECT_TRUE(Set.contains(0));
+  EXPECT_TRUE(Set.contains(1));
+  EXPECT_TRUE(Set.contains(2));
+}
diff --git a/wpiutil/src/test/native/cpp/llvm/SmallStringTest.cpp b/wpiutil/src/test/native/cpp/llvm/SmallStringTest.cpp
new file mode 100644
index 0000000..afb155a
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/SmallStringTest.cpp
@@ -0,0 +1,166 @@
+//===- llvm/unittest/ADT/SmallStringTest.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// SmallString unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SmallString.h"
+#include "gtest/gtest.h"
+#include <climits>
+#include <cstring>
+#include <stdarg.h>
+
+using namespace wpi;
+
+namespace {
+
+// Test fixture class
+class SmallStringTest : public testing::Test {
+protected:
+  typedef SmallString<40> StringType;
+
+  StringType theString;
+
+  void assertEmpty(StringType & v) {
+    // Size tests
+    EXPECT_EQ(0u, v.size());
+    EXPECT_TRUE(v.empty());
+    // Iterator tests
+    EXPECT_TRUE(v.begin() == v.end());
+  }
+};
+
+// New string test.
+TEST_F(SmallStringTest, EmptyStringTest) {
+  SCOPED_TRACE("EmptyStringTest");
+  assertEmpty(theString);
+  EXPECT_TRUE(theString.rbegin() == theString.rend());
+}
+
+TEST_F(SmallStringTest, AssignRepeated) {
+  theString.assign(3, 'a');
+  EXPECT_EQ(3u, theString.size());
+  EXPECT_STREQ("aaa", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AssignIterPair) {
+  std::string_view abc = "abc";
+  theString.assign(abc.begin(), abc.end());
+  EXPECT_EQ(3u, theString.size());
+  EXPECT_STREQ("abc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AssignStringView) {
+  std::string_view abc = "abc";
+  theString.assign(abc);
+  EXPECT_EQ(3u, theString.size());
+  EXPECT_STREQ("abc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AssignSmallVector) {
+  std::string_view abc = "abc";
+  SmallVector<char, 10> abcVec(abc.begin(), abc.end());
+  theString.assign(abcVec);
+  EXPECT_EQ(3u, theString.size());
+  EXPECT_STREQ("abc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AssignStringViews) {
+  theString.assign({"abc", "def", "ghi"});
+  EXPECT_EQ(9u, theString.size());
+  EXPECT_STREQ("abcdefghi", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AppendIterPair) {
+  std::string_view abc = "abc";
+  theString.append(abc.begin(), abc.end());
+  theString.append(abc.begin(), abc.end());
+  EXPECT_EQ(6u, theString.size());
+  EXPECT_STREQ("abcabc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AppendStringView) {
+  std::string_view abc = "abc";
+  theString.append(abc);
+  theString.append(abc);
+  EXPECT_EQ(6u, theString.size());
+  EXPECT_STREQ("abcabc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AppendSmallVector) {
+  std::string_view abc = "abc";
+  SmallVector<char, 10> abcVec(abc.begin(), abc.end());
+  theString.append(abcVec);
+  theString.append(abcVec);
+  EXPECT_EQ(6u, theString.size());
+  EXPECT_STREQ("abcabc", theString.c_str());
+}
+
+TEST_F(SmallStringTest, AppendStringViews) {
+  theString.append({"abc", "def", "ghi"});
+  EXPECT_EQ(9u, theString.size());
+  EXPECT_STREQ("abcdefghi", theString.c_str());
+  std::string_view Jkl = "jkl";
+  std::string Mno = "mno";
+  SmallString<4> Pqr("pqr");
+  const char *Stu = "stu";
+  theString.append({Jkl, Mno, Pqr, Stu});
+  EXPECT_EQ(21u, theString.size());
+  EXPECT_STREQ("abcdefghijklmnopqrstu", theString.c_str());
+}
+
+TEST_F(SmallStringTest, StringViewConversion) {
+  std::string_view abc = "abc";
+  theString.assign(abc.begin(), abc.end());
+  std::string_view theStringView = theString;
+  EXPECT_EQ("abc", theStringView);
+}
+
+TEST_F(SmallStringTest, StdStringConversion) {
+  std::string_view abc = "abc";
+  theString.assign(abc.begin(), abc.end());
+  std::string theStdString = std::string(theString);
+  EXPECT_EQ("abc", theStdString);
+}
+
+TEST_F(SmallStringTest, Find) {
+  theString = "hello";
+  EXPECT_EQ(2U, theString.find('l'));
+  EXPECT_EQ(std::string_view::npos, theString.find('z'));
+  EXPECT_EQ(std::string_view::npos, theString.find("helloworld"));
+  EXPECT_EQ(0U, theString.find("hello"));
+  EXPECT_EQ(1U, theString.find("ello"));
+  EXPECT_EQ(std::string_view::npos, theString.find("zz"));
+  EXPECT_EQ(2U, theString.find("ll", 2));
+  EXPECT_EQ(std::string_view::npos, theString.find("ll", 3));
+  EXPECT_EQ(0U, theString.find(""));
+
+  EXPECT_EQ(3U, theString.rfind('l'));
+  EXPECT_EQ(std::string_view::npos, theString.rfind('z'));
+  EXPECT_EQ(std::string_view::npos, theString.rfind("helloworld"));
+  EXPECT_EQ(0U, theString.rfind("hello"));
+  EXPECT_EQ(1U, theString.rfind("ello"));
+  EXPECT_EQ(std::string_view::npos, theString.rfind("zz"));
+
+  EXPECT_EQ(2U, theString.find_first_of('l'));
+  EXPECT_EQ(1U, theString.find_first_of("el"));
+  EXPECT_EQ(std::string_view::npos, theString.find_first_of("xyz"));
+
+  EXPECT_EQ(1U, theString.find_first_not_of('h'));
+  EXPECT_EQ(4U, theString.find_first_not_of("hel"));
+  EXPECT_EQ(std::string_view::npos, theString.find_first_not_of("hello"));
+
+  theString = "hellx xello hell ello world foo bar hello";
+  EXPECT_EQ(36U, theString.find("hello"));
+  EXPECT_EQ(28U, theString.find("foo"));
+  EXPECT_EQ(12U, theString.find("hell", 2));
+  EXPECT_EQ(0U, theString.find(""));
+}
+
+} // namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/SmallVectorTest.cpp b/wpiutil/src/test/native/cpp/llvm/SmallVectorTest.cpp
new file mode 100644
index 0000000..a60e683
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/SmallVectorTest.cpp
@@ -0,0 +1,1425 @@
+//===- llvm/unittest/ADT/SmallVectorTest.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// SmallVector unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SmallVector.h"
+#include <span>
+#include "wpi/Compiler.h"
+#include "gtest/gtest.h"
+#include <list>
+#include <stdarg.h>
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+using namespace wpi;
+
+namespace {
+
+/// A helper class that counts the total number of constructor and
+/// destructor calls.
+class Constructable {
+private:
+  static int numConstructorCalls;
+  static int numMoveConstructorCalls;
+  static int numCopyConstructorCalls;
+  static int numDestructorCalls;
+  static int numAssignmentCalls;
+  static int numMoveAssignmentCalls;
+  static int numCopyAssignmentCalls;
+
+  bool constructed;
+  int value;
+
+public:
+  Constructable() : constructed(true), value(0) {
+    ++numConstructorCalls;
+  }
+
+  Constructable(int val) : constructed(true), value(val) {
+    ++numConstructorCalls;
+  }
+
+  Constructable(const Constructable & src) : constructed(true) {
+    value = src.value;
+    ++numConstructorCalls;
+    ++numCopyConstructorCalls;
+  }
+
+  Constructable(Constructable && src) : constructed(true) {
+    value = src.value;
+    src.value = 0;
+    ++numConstructorCalls;
+    ++numMoveConstructorCalls;
+  }
+
+  ~Constructable() {
+    EXPECT_TRUE(constructed);
+    ++numDestructorCalls;
+    constructed = false;
+  }
+
+  Constructable & operator=(const Constructable & src) {
+    EXPECT_TRUE(constructed);
+    value = src.value;
+    ++numAssignmentCalls;
+    ++numCopyAssignmentCalls;
+    return *this;
+  }
+
+  Constructable & operator=(Constructable && src) {
+    EXPECT_TRUE(constructed);
+    value = src.value;
+    src.value = 0;
+    ++numAssignmentCalls;
+    ++numMoveAssignmentCalls;
+    return *this;
+  }
+
+  int getValue() const {
+    return abs(value);
+  }
+
+  static void reset() {
+    numConstructorCalls = 0;
+    numMoveConstructorCalls = 0;
+    numCopyConstructorCalls = 0;
+    numDestructorCalls = 0;
+    numAssignmentCalls = 0;
+    numMoveAssignmentCalls = 0;
+    numCopyAssignmentCalls = 0;
+  }
+
+  static int getNumConstructorCalls() {
+    return numConstructorCalls;
+  }
+
+  static int getNumMoveConstructorCalls() {
+    return numMoveConstructorCalls;
+  }
+
+  static int getNumCopyConstructorCalls() {
+    return numCopyConstructorCalls;
+  }
+
+  static int getNumDestructorCalls() {
+    return numDestructorCalls;
+  }
+
+  static int getNumAssignmentCalls() {
+    return numAssignmentCalls;
+  }
+
+  static int getNumMoveAssignmentCalls() {
+    return numMoveAssignmentCalls;
+  }
+
+  static int getNumCopyAssignmentCalls() {
+    return numCopyAssignmentCalls;
+  }
+
+  friend bool operator==(const Constructable & c0, const Constructable & c1) {
+    return c0.getValue() == c1.getValue();
+  }
+
+  friend bool LLVM_ATTRIBUTE_UNUSED
+  operator!=(const Constructable & c0, const Constructable & c1) {
+    return c0.getValue() != c1.getValue();
+  }
+};
+
+int Constructable::numConstructorCalls;
+int Constructable::numCopyConstructorCalls;
+int Constructable::numMoveConstructorCalls;
+int Constructable::numDestructorCalls;
+int Constructable::numAssignmentCalls;
+int Constructable::numCopyAssignmentCalls;
+int Constructable::numMoveAssignmentCalls;
+
+struct NonCopyable {
+  NonCopyable() {}
+  NonCopyable(NonCopyable &&) {}
+  NonCopyable &operator=(NonCopyable &&) { return *this; }
+private:
+  NonCopyable(const NonCopyable &) = delete;
+  NonCopyable &operator=(const NonCopyable &) = delete;
+};
+
+LLVM_ATTRIBUTE_USED void CompileTest() {
+  SmallVector<NonCopyable, 0> V;
+  V.resize(42);
+}
+
+class SmallVectorTestBase : public testing::Test {
+protected:
+  void SetUp() override { Constructable::reset(); }
+
+  template <typename VectorT>
+  void assertEmpty(VectorT & v) {
+    // Size tests
+    EXPECT_EQ(0u, v.size());
+    EXPECT_TRUE(v.empty());
+
+    // Iterator tests
+    EXPECT_TRUE(v.begin() == v.end());
+  }
+
+  // Assert that v contains the specified values, in order.
+  template <typename VectorT>
+  void assertValuesInOrder(VectorT & v, size_t size, ...) {
+    EXPECT_EQ(size, v.size());
+
+    va_list ap;
+    va_start(ap, size);
+    for (size_t i = 0; i < size; ++i) {
+      int value = va_arg(ap, int);
+      EXPECT_EQ(value, v[i].getValue());
+    }
+
+    va_end(ap);
+  }
+
+  // Generate a sequence of values to initialize the vector.
+  template <typename VectorT>
+  void makeSequence(VectorT & v, int start, int end) {
+    for (int i = start; i <= end; ++i) {
+      v.push_back(Constructable(i));
+    }
+  }
+};
+
+// Test fixture class
+template <typename VectorT>
+class SmallVectorTest : public SmallVectorTestBase {
+protected:
+  VectorT theVector;
+  VectorT otherVector;
+};
+
+
+typedef ::testing::Types<SmallVector<Constructable, 0>,
+                         SmallVector<Constructable, 1>,
+                         SmallVector<Constructable, 2>,
+                         SmallVector<Constructable, 4>,
+                         SmallVector<Constructable, 5>
+                         > SmallVectorTestTypes;
+TYPED_TEST_SUITE(SmallVectorTest, SmallVectorTestTypes, );
+
+// Constructor test.
+TYPED_TEST(SmallVectorTest, ConstructorNonIterTest) {
+  SCOPED_TRACE("ConstructorTest");
+  this->theVector = SmallVector<Constructable, 2>(2, 2);
+  this->assertValuesInOrder(this->theVector, 2u, 2, 2);
+}
+
+// Constructor test.
+TYPED_TEST(SmallVectorTest, ConstructorIterTest) {
+  SCOPED_TRACE("ConstructorTest");
+  int arr[] = {1, 2, 3};
+  this->theVector =
+      SmallVector<Constructable, 4>(std::begin(arr), std::end(arr));
+  this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
+}
+
+// New vector test.
+TYPED_TEST(SmallVectorTest, EmptyVectorTest) {
+  SCOPED_TRACE("EmptyVectorTest");
+  this->assertEmpty(this->theVector);
+  EXPECT_TRUE(this->theVector.rbegin() == this->theVector.rend());
+  EXPECT_EQ(0, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(0, Constructable::getNumDestructorCalls());
+}
+
+// Simple insertions and deletions.
+TYPED_TEST(SmallVectorTest, PushPopTest) {
+  SCOPED_TRACE("PushPopTest");
+
+  // Track whether the vector will potentially have to grow.
+  bool RequiresGrowth = this->theVector.capacity() < 3;
+
+  // Push an element
+  this->theVector.push_back(Constructable(1));
+
+  // Size tests
+  this->assertValuesInOrder(this->theVector, 1u, 1);
+  EXPECT_FALSE(this->theVector.begin() == this->theVector.end());
+  EXPECT_FALSE(this->theVector.empty());
+
+  // Push another element
+  this->theVector.push_back(Constructable(2));
+  this->assertValuesInOrder(this->theVector, 2u, 1, 2);
+
+  // Insert at beginning. Reserve space to avoid reference invalidation from
+  // this->theVector[1].
+  this->theVector.reserve(this->theVector.size() + 1);
+  this->theVector.insert(this->theVector.begin(), this->theVector[1]);
+  this->assertValuesInOrder(this->theVector, 3u, 2, 1, 2);
+
+  // Pop one element
+  this->theVector.pop_back();
+  this->assertValuesInOrder(this->theVector, 2u, 2, 1);
+
+  // Pop remaining elements
+  this->theVector.pop_back_n(2);
+  this->assertEmpty(this->theVector);
+
+  // Check number of constructor calls. Should be 2 for each list element,
+  // one for the argument to push_back, one for the argument to insert,
+  // and one for the list element itself.
+  if (!RequiresGrowth) {
+    EXPECT_EQ(5, Constructable::getNumConstructorCalls());
+    EXPECT_EQ(5, Constructable::getNumDestructorCalls());
+  } else {
+    // If we had to grow the vector, these only have a lower bound, but should
+    // always be equal.
+    EXPECT_LE(5, Constructable::getNumConstructorCalls());
+    EXPECT_EQ(Constructable::getNumConstructorCalls(),
+              Constructable::getNumDestructorCalls());
+  }
+}
+
+// Clear test.
+TYPED_TEST(SmallVectorTest, ClearTest) {
+  SCOPED_TRACE("ClearTest");
+
+  this->theVector.reserve(2);
+  this->makeSequence(this->theVector, 1, 2);
+  this->theVector.clear();
+
+  this->assertEmpty(this->theVector);
+  EXPECT_EQ(4, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(4, Constructable::getNumDestructorCalls());
+}
+
+// Resize smaller test.
+TYPED_TEST(SmallVectorTest, ResizeShrinkTest) {
+  SCOPED_TRACE("ResizeShrinkTest");
+
+  this->theVector.reserve(3);
+  this->makeSequence(this->theVector, 1, 3);
+  this->theVector.resize(1);
+
+  this->assertValuesInOrder(this->theVector, 1u, 1);
+  EXPECT_EQ(6, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(5, Constructable::getNumDestructorCalls());
+}
+
+// Truncate test.
+TYPED_TEST(SmallVectorTest, TruncateTest) {
+  SCOPED_TRACE("TruncateTest");
+
+  this->theVector.reserve(3);
+  this->makeSequence(this->theVector, 1, 3);
+  this->theVector.truncate(1);
+
+  this->assertValuesInOrder(this->theVector, 1u, 1);
+  EXPECT_EQ(6, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(5, Constructable::getNumDestructorCalls());
+
+#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
+  EXPECT_DEATH(this->theVector.truncate(2), "Cannot increase size");
+#endif
+  this->theVector.truncate(1);
+  this->assertValuesInOrder(this->theVector, 1u, 1);
+  EXPECT_EQ(6, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(5, Constructable::getNumDestructorCalls());
+
+  this->theVector.truncate(0);
+  this->assertEmpty(this->theVector);
+  EXPECT_EQ(6, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(6, Constructable::getNumDestructorCalls());
+}
+
+// Resize bigger test.
+TYPED_TEST(SmallVectorTest, ResizeGrowTest) {
+  SCOPED_TRACE("ResizeGrowTest");
+
+  this->theVector.resize(2);
+
+  EXPECT_EQ(2, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(0, Constructable::getNumDestructorCalls());
+  EXPECT_EQ(2u, this->theVector.size());
+}
+
+TYPED_TEST(SmallVectorTest, ResizeWithElementsTest) {
+  this->theVector.resize(2);
+
+  Constructable::reset();
+
+  this->theVector.resize(4);
+
+  size_t Ctors = Constructable::getNumConstructorCalls();
+  EXPECT_TRUE(Ctors == 2 || Ctors == 4);
+  size_t MoveCtors = Constructable::getNumMoveConstructorCalls();
+  EXPECT_TRUE(MoveCtors == 0 || MoveCtors == 2);
+  size_t Dtors = Constructable::getNumDestructorCalls();
+  EXPECT_TRUE(Dtors == 0 || Dtors == 2);
+}
+
+// Resize with fill value.
+TYPED_TEST(SmallVectorTest, ResizeFillTest) {
+  SCOPED_TRACE("ResizeFillTest");
+
+  this->theVector.resize(3, Constructable(77));
+  this->assertValuesInOrder(this->theVector, 3u, 77, 77, 77);
+}
+
+TEST(SmallVectorTest, ResizeForOverwrite) {
+  {
+    // Heap allocated storage.
+    SmallVector<unsigned, 0> V;
+    V.push_back(5U);
+    V.pop_back();
+    V.resize_for_overwrite(V.size() + 1U);
+    EXPECT_EQ(5U, V.back());
+    V.pop_back();
+    V.resize(V.size() + 1);
+    EXPECT_EQ(0U, V.back());
+  }
+  {
+    // Inline storage.
+    SmallVector<unsigned, 2> V;
+    V.push_back(5U);
+    V.pop_back();
+    V.resize_for_overwrite(V.size() + 1U);
+    EXPECT_EQ(5U, V.back());
+    V.pop_back();
+    V.resize(V.size() + 1);
+    EXPECT_EQ(0U, V.back());
+  }
+}
+
+// Overflow past fixed size.
+TYPED_TEST(SmallVectorTest, OverflowTest) {
+  SCOPED_TRACE("OverflowTest");
+
+  // Push more elements than the fixed size.
+  this->makeSequence(this->theVector, 1, 10);
+
+  // Test size and values.
+  EXPECT_EQ(10u, this->theVector.size());
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_EQ(i+1, this->theVector[i].getValue());
+  }
+
+  // Now resize back to fixed size.
+  this->theVector.resize(1);
+
+  this->assertValuesInOrder(this->theVector, 1u, 1);
+}
+
+// Iteration tests.
+TYPED_TEST(SmallVectorTest, IterationTest) {
+  this->makeSequence(this->theVector, 1, 2);
+
+  // Forward Iteration
+  typename TypeParam::iterator it = this->theVector.begin();
+  EXPECT_TRUE(*it == this->theVector.front());
+  EXPECT_TRUE(*it == this->theVector[0]);
+  EXPECT_EQ(1, it->getValue());
+  ++it;
+  EXPECT_TRUE(*it == this->theVector[1]);
+  EXPECT_TRUE(*it == this->theVector.back());
+  EXPECT_EQ(2, it->getValue());
+  ++it;
+  EXPECT_TRUE(it == this->theVector.end());
+  --it;
+  EXPECT_TRUE(*it == this->theVector[1]);
+  EXPECT_EQ(2, it->getValue());
+  --it;
+  EXPECT_TRUE(*it == this->theVector[0]);
+  EXPECT_EQ(1, it->getValue());
+
+  // Reverse Iteration
+  typename TypeParam::reverse_iterator rit = this->theVector.rbegin();
+  EXPECT_TRUE(*rit == this->theVector[1]);
+  EXPECT_EQ(2, rit->getValue());
+  ++rit;
+  EXPECT_TRUE(*rit == this->theVector[0]);
+  EXPECT_EQ(1, rit->getValue());
+  ++rit;
+  EXPECT_TRUE(rit == this->theVector.rend());
+  --rit;
+  EXPECT_TRUE(*rit == this->theVector[0]);
+  EXPECT_EQ(1, rit->getValue());
+  --rit;
+  EXPECT_TRUE(*rit == this->theVector[1]);
+  EXPECT_EQ(2, rit->getValue());
+}
+
+// Swap test.
+TYPED_TEST(SmallVectorTest, SwapTest) {
+  SCOPED_TRACE("SwapTest");
+
+  this->makeSequence(this->theVector, 1, 2);
+  std::swap(this->theVector, this->otherVector);
+
+  this->assertEmpty(this->theVector);
+  this->assertValuesInOrder(this->otherVector, 2u, 1, 2);
+}
+
+// Append test
+TYPED_TEST(SmallVectorTest, AppendTest) {
+  SCOPED_TRACE("AppendTest");
+
+  this->makeSequence(this->otherVector, 2, 3);
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.append(this->otherVector.begin(), this->otherVector.end());
+
+  this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
+}
+
+// Append repeated test
+TYPED_TEST(SmallVectorTest, AppendRepeatedTest) {
+  SCOPED_TRACE("AppendRepeatedTest");
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.append(2, Constructable(77));
+  this->assertValuesInOrder(this->theVector, 3u, 1, 77, 77);
+}
+
+// Append test
+TYPED_TEST(SmallVectorTest, AppendNonIterTest) {
+  SCOPED_TRACE("AppendRepeatedTest");
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.append(2, 7);
+  this->assertValuesInOrder(this->theVector, 3u, 1, 7, 7);
+}
+
+struct output_iterator {
+  typedef std::output_iterator_tag iterator_category;
+  typedef int value_type;
+  typedef int difference_type;
+  typedef value_type *pointer;
+  typedef value_type &reference;
+  operator int() { return 2; }
+  operator Constructable() { return 7; }
+};
+
+TYPED_TEST(SmallVectorTest, AppendRepeatedNonForwardIterator) {
+  SCOPED_TRACE("AppendRepeatedTest");
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.append(output_iterator(), output_iterator());
+  this->assertValuesInOrder(this->theVector, 3u, 1, 7, 7);
+}
+
+TYPED_TEST(SmallVectorTest, AppendSmallVector) {
+  SCOPED_TRACE("AppendSmallVector");
+
+  SmallVector<Constructable, 3> otherVector = {7, 7};
+  this->theVector.push_back(Constructable(1));
+  this->theVector.append(otherVector);
+  this->assertValuesInOrder(this->theVector, 3u, 1, 7, 7);
+}
+
+// Assign test
+TYPED_TEST(SmallVectorTest, AssignTest) {
+  SCOPED_TRACE("AssignTest");
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.assign(2, Constructable(77));
+  this->assertValuesInOrder(this->theVector, 2u, 77, 77);
+}
+
+// Assign test
+TYPED_TEST(SmallVectorTest, AssignRangeTest) {
+  SCOPED_TRACE("AssignTest");
+
+  this->theVector.push_back(Constructable(1));
+  int arr[] = {1, 2, 3};
+  this->theVector.assign(std::begin(arr), std::end(arr));
+  this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
+}
+
+// Assign test
+TYPED_TEST(SmallVectorTest, AssignNonIterTest) {
+  SCOPED_TRACE("AssignTest");
+
+  this->theVector.push_back(Constructable(1));
+  this->theVector.assign(2, 7);
+  this->assertValuesInOrder(this->theVector, 2u, 7, 7);
+}
+
+TYPED_TEST(SmallVectorTest, AssignSmallVector) {
+  SCOPED_TRACE("AssignSmallVector");
+
+  SmallVector<Constructable, 3> otherVector = {7, 7};
+  this->theVector.push_back(Constructable(1));
+  this->theVector.assign(otherVector);
+  this->assertValuesInOrder(this->theVector, 2u, 7, 7);
+}
+
+// Move-assign test
+TYPED_TEST(SmallVectorTest, MoveAssignTest) {
+  SCOPED_TRACE("MoveAssignTest");
+
+  // Set up our vector with a single element, but enough capacity for 4.
+  this->theVector.reserve(4);
+  this->theVector.push_back(Constructable(1));
+  
+  // Set up the other vector with 2 elements.
+  this->otherVector.push_back(Constructable(2));
+  this->otherVector.push_back(Constructable(3));
+
+  // Move-assign from the other vector.
+  this->theVector = std::move(this->otherVector);
+
+  // Make sure we have the right result.
+  this->assertValuesInOrder(this->theVector, 2u, 2, 3);
+
+  // Make sure the # of constructor/destructor calls line up. There
+  // are two live objects after clearing the other vector.
+  this->otherVector.clear();
+  EXPECT_EQ(Constructable::getNumConstructorCalls()-2, 
+            Constructable::getNumDestructorCalls());
+
+  // There shouldn't be any live objects any more.
+  this->theVector.clear();
+  EXPECT_EQ(Constructable::getNumConstructorCalls(), 
+            Constructable::getNumDestructorCalls());
+}
+
+// Erase a single element
+TYPED_TEST(SmallVectorTest, EraseTest) {
+  SCOPED_TRACE("EraseTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+  const auto &theConstVector = this->theVector;
+  this->theVector.erase(theConstVector.begin());
+  this->assertValuesInOrder(this->theVector, 2u, 2, 3);
+}
+
+// Erase a range of elements
+TYPED_TEST(SmallVectorTest, EraseRangeTest) {
+  SCOPED_TRACE("EraseRangeTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+  const auto &theConstVector = this->theVector;
+  this->theVector.erase(theConstVector.begin(), theConstVector.begin() + 2);
+  this->assertValuesInOrder(this->theVector, 1u, 3);
+}
+
+// Insert a single element.
+TYPED_TEST(SmallVectorTest, InsertTest) {
+  SCOPED_TRACE("InsertTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+  typename TypeParam::iterator I =
+    this->theVector.insert(this->theVector.begin() + 1, Constructable(77));
+  EXPECT_EQ(this->theVector.begin() + 1, I);
+  this->assertValuesInOrder(this->theVector, 4u, 1, 77, 2, 3);
+}
+
+// Insert a copy of a single element.
+TYPED_TEST(SmallVectorTest, InsertCopy) {
+  SCOPED_TRACE("InsertTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+  Constructable C(77);
+  typename TypeParam::iterator I =
+      this->theVector.insert(this->theVector.begin() + 1, C);
+  EXPECT_EQ(this->theVector.begin() + 1, I);
+  this->assertValuesInOrder(this->theVector, 4u, 1, 77, 2, 3);
+}
+
+// Insert repeated elements.
+TYPED_TEST(SmallVectorTest, InsertRepeatedTest) {
+  SCOPED_TRACE("InsertRepeatedTest");
+
+  this->makeSequence(this->theVector, 1, 4);
+  Constructable::reset();
+  auto I =
+      this->theVector.insert(this->theVector.begin() + 1, 2, Constructable(16));
+  // Move construct the top element into newly allocated space, and optionally
+  // reallocate the whole buffer, move constructing into it.
+  // FIXME: This is inefficient, we shouldn't move things into newly allocated
+  // space, then move them up/around, there should only be 2 or 4 move
+  // constructions here.
+  EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 2 ||
+              Constructable::getNumMoveConstructorCalls() == 6);
+  // Move assign the next two to shift them up and make a gap.
+  EXPECT_EQ(1, Constructable::getNumMoveAssignmentCalls());
+  // Copy construct the two new elements from the parameter.
+  EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
+  // All without any copy construction.
+  EXPECT_EQ(0, Constructable::getNumCopyConstructorCalls());
+  EXPECT_EQ(this->theVector.begin() + 1, I);
+  this->assertValuesInOrder(this->theVector, 6u, 1, 16, 16, 2, 3, 4);
+}
+
+TYPED_TEST(SmallVectorTest, InsertRepeatedNonIterTest) {
+  SCOPED_TRACE("InsertRepeatedTest");
+
+  this->makeSequence(this->theVector, 1, 4);
+  Constructable::reset();
+  auto I = this->theVector.insert(this->theVector.begin() + 1, 2, 7);
+  EXPECT_EQ(this->theVector.begin() + 1, I);
+  this->assertValuesInOrder(this->theVector, 6u, 1, 7, 7, 2, 3, 4);
+}
+
+TYPED_TEST(SmallVectorTest, InsertRepeatedAtEndTest) {
+  SCOPED_TRACE("InsertRepeatedTest");
+
+  this->makeSequence(this->theVector, 1, 4);
+  Constructable::reset();
+  auto I = this->theVector.insert(this->theVector.end(), 2, Constructable(16));
+  // Just copy construct them into newly allocated space
+  EXPECT_EQ(2, Constructable::getNumCopyConstructorCalls());
+  // Move everything across if reallocation is needed.
+  EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 0 ||
+              Constructable::getNumMoveConstructorCalls() == 4);
+  // Without ever moving or copying anything else.
+  EXPECT_EQ(0, Constructable::getNumCopyAssignmentCalls());
+  EXPECT_EQ(0, Constructable::getNumMoveAssignmentCalls());
+
+  EXPECT_EQ(this->theVector.begin() + 4, I);
+  this->assertValuesInOrder(this->theVector, 6u, 1, 2, 3, 4, 16, 16);
+}
+
+TYPED_TEST(SmallVectorTest, InsertRepeatedEmptyTest) {
+  SCOPED_TRACE("InsertRepeatedTest");
+
+  this->makeSequence(this->theVector, 10, 15);
+
+  // Empty insert.
+  EXPECT_EQ(this->theVector.end(),
+            this->theVector.insert(this->theVector.end(),
+                                   0, Constructable(42)));
+  EXPECT_EQ(this->theVector.begin() + 1,
+            this->theVector.insert(this->theVector.begin() + 1,
+                                   0, Constructable(42)));
+}
+
+// Insert range.
+TYPED_TEST(SmallVectorTest, InsertRangeTest) {
+  SCOPED_TRACE("InsertRangeTest");
+
+  Constructable Arr[3] =
+    { Constructable(77), Constructable(77), Constructable(77) };
+
+  this->makeSequence(this->theVector, 1, 3);
+  Constructable::reset();
+  auto I = this->theVector.insert(this->theVector.begin() + 1, Arr, Arr + 3);
+  // Move construct the top 3 elements into newly allocated space.
+  // Possibly move the whole sequence into new space first.
+  // FIXME: This is inefficient, we shouldn't move things into newly allocated
+  // space, then move them up/around, there should only be 2 or 3 move
+  // constructions here.
+  EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 2 ||
+              Constructable::getNumMoveConstructorCalls() == 5);
+  // Copy assign the lower 2 new elements into existing space.
+  EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
+  // Copy construct the third element into newly allocated space.
+  EXPECT_EQ(1, Constructable::getNumCopyConstructorCalls());
+  EXPECT_EQ(this->theVector.begin() + 1, I);
+  this->assertValuesInOrder(this->theVector, 6u, 1, 77, 77, 77, 2, 3);
+}
+
+
+TYPED_TEST(SmallVectorTest, InsertRangeAtEndTest) {
+  SCOPED_TRACE("InsertRangeTest");
+
+  Constructable Arr[3] =
+    { Constructable(77), Constructable(77), Constructable(77) };
+
+  this->makeSequence(this->theVector, 1, 3);
+
+  // Insert at end.
+  Constructable::reset();
+  auto I = this->theVector.insert(this->theVector.end(), Arr, Arr+3);
+  // Copy construct the 3 elements into new space at the top.
+  EXPECT_EQ(3, Constructable::getNumCopyConstructorCalls());
+  // Don't copy/move anything else.
+  EXPECT_EQ(0, Constructable::getNumCopyAssignmentCalls());
+  // Reallocation might occur, causing all elements to be moved into the new
+  // buffer.
+  EXPECT_TRUE(Constructable::getNumMoveConstructorCalls() == 0 ||
+              Constructable::getNumMoveConstructorCalls() == 3);
+  EXPECT_EQ(0, Constructable::getNumMoveAssignmentCalls());
+  EXPECT_EQ(this->theVector.begin() + 3, I);
+  this->assertValuesInOrder(this->theVector, 6u,
+                            1, 2, 3, 77, 77, 77);
+}
+
+TYPED_TEST(SmallVectorTest, InsertEmptyRangeTest) {
+  SCOPED_TRACE("InsertRangeTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+
+  // Empty insert.
+  EXPECT_EQ(this->theVector.end(),
+            this->theVector.insert(this->theVector.end(),
+                                   this->theVector.begin(),
+                                   this->theVector.begin()));
+  EXPECT_EQ(this->theVector.begin() + 1,
+            this->theVector.insert(this->theVector.begin() + 1,
+                                   this->theVector.begin(),
+                                   this->theVector.begin()));
+}
+
+// Comparison tests.
+TYPED_TEST(SmallVectorTest, ComparisonTest) {
+  SCOPED_TRACE("ComparisonTest");
+
+  this->makeSequence(this->theVector, 1, 3);
+  this->makeSequence(this->otherVector, 1, 3);
+
+  EXPECT_TRUE(this->theVector == this->otherVector);
+  EXPECT_FALSE(this->theVector != this->otherVector);
+
+  this->otherVector.clear();
+  this->makeSequence(this->otherVector, 2, 4);
+
+  EXPECT_FALSE(this->theVector == this->otherVector);
+  EXPECT_TRUE(this->theVector != this->otherVector);
+}
+
+// Constant vector tests.
+TYPED_TEST(SmallVectorTest, ConstVectorTest) {
+  const TypeParam constVector;
+
+  EXPECT_EQ(0u, constVector.size());
+  EXPECT_TRUE(constVector.empty());
+  EXPECT_TRUE(constVector.begin() == constVector.end());
+}
+
+// Direct array access.
+TYPED_TEST(SmallVectorTest, DirectVectorTest) {
+  EXPECT_EQ(0u, this->theVector.size());
+  this->theVector.reserve(4);
+  EXPECT_LE(4u, this->theVector.capacity());
+  EXPECT_EQ(0, Constructable::getNumConstructorCalls());
+  this->theVector.push_back(1);
+  this->theVector.push_back(2);
+  this->theVector.push_back(3);
+  this->theVector.push_back(4);
+  EXPECT_EQ(4u, this->theVector.size());
+  EXPECT_EQ(8, Constructable::getNumConstructorCalls());
+  EXPECT_EQ(1, this->theVector[0].getValue());
+  EXPECT_EQ(2, this->theVector[1].getValue());
+  EXPECT_EQ(3, this->theVector[2].getValue());
+  EXPECT_EQ(4, this->theVector[3].getValue());
+}
+
+TYPED_TEST(SmallVectorTest, IteratorTest) {
+  std::list<int> L;
+  this->theVector.insert(this->theVector.end(), L.begin(), L.end());
+}
+
+template <typename InvalidType> class DualSmallVectorsTest;
+
+template <typename VectorT1, typename VectorT2>
+class DualSmallVectorsTest<std::pair<VectorT1, VectorT2>> : public SmallVectorTestBase {
+protected:
+  VectorT1 theVector;
+  VectorT2 otherVector;
+
+  template <typename T, unsigned N>
+  static unsigned NumBuiltinElts(const SmallVector<T, N>&) { return N; }
+};
+
+typedef ::testing::Types<
+    // Small mode -> Small mode.
+    std::pair<SmallVector<Constructable, 4>, SmallVector<Constructable, 4>>,
+    // Small mode -> Big mode.
+    std::pair<SmallVector<Constructable, 4>, SmallVector<Constructable, 2>>,
+    // Big mode -> Small mode.
+    std::pair<SmallVector<Constructable, 2>, SmallVector<Constructable, 4>>,
+    // Big mode -> Big mode.
+    std::pair<SmallVector<Constructable, 2>, SmallVector<Constructable, 2>>
+  > DualSmallVectorTestTypes;
+
+TYPED_TEST_SUITE(DualSmallVectorsTest, DualSmallVectorTestTypes, );
+
+TYPED_TEST(DualSmallVectorsTest, MoveAssignment) {
+  SCOPED_TRACE("MoveAssignTest-DualVectorTypes");
+
+  // Set up our vector with four elements.
+  for (unsigned I = 0; I < 4; ++I)
+    this->otherVector.push_back(Constructable(I));
+
+  const Constructable *OrigDataPtr = this->otherVector.data();
+
+  // Move-assign from the other vector.
+  this->theVector =
+    std::move(static_cast<SmallVectorImpl<Constructable>&>(this->otherVector));
+
+  // Make sure we have the right result.
+  this->assertValuesInOrder(this->theVector, 4u, 0, 1, 2, 3);
+
+  // Make sure the # of constructor/destructor calls line up. There
+  // are two live objects after clearing the other vector.
+  this->otherVector.clear();
+  EXPECT_EQ(Constructable::getNumConstructorCalls()-4,
+            Constructable::getNumDestructorCalls());
+
+  // If the source vector (otherVector) was in small-mode, assert that we just
+  // moved the data pointer over.
+  EXPECT_TRUE(this->NumBuiltinElts(this->otherVector) == 4 ||
+              this->theVector.data() == OrigDataPtr);
+
+  // There shouldn't be any live objects any more.
+  this->theVector.clear();
+  EXPECT_EQ(Constructable::getNumConstructorCalls(),
+            Constructable::getNumDestructorCalls());
+
+  // We shouldn't have copied anything in this whole process.
+  EXPECT_EQ(Constructable::getNumCopyConstructorCalls(), 0);
+}
+
+struct notassignable {
+  int &x;
+  notassignable(int &x) : x(x) {}
+};
+
+TEST(SmallVectorCustomTest, NoAssignTest) {
+  int x = 0;
+  SmallVector<notassignable, 2> vec;
+  vec.push_back(notassignable(x));
+  x = 42;
+  EXPECT_EQ(42, vec.pop_back_val().x);
+}
+
+struct MovedFrom {
+  bool hasValue;
+  MovedFrom() : hasValue(true) {
+  }
+  MovedFrom(MovedFrom&& m) : hasValue(m.hasValue) {
+    m.hasValue = false;
+  }
+  MovedFrom &operator=(MovedFrom&& m) {
+    hasValue = m.hasValue;
+    m.hasValue = false;
+    return *this;
+  }
+};
+
+TEST(SmallVectorTest, MidInsert) {
+  SmallVector<MovedFrom, 3> v;
+  v.push_back(MovedFrom());
+  v.insert(v.begin(), MovedFrom());
+  for (MovedFrom &m : v)
+    EXPECT_TRUE(m.hasValue);
+}
+
+enum EmplaceableArgState {
+  EAS_Defaulted,
+  EAS_Arg,
+  EAS_LValue,
+  EAS_RValue,
+  EAS_Failure
+};
+template <int I> struct EmplaceableArg {
+  EmplaceableArgState State;
+  EmplaceableArg() : State(EAS_Defaulted) {}
+  EmplaceableArg(EmplaceableArg &&X)
+      : State(X.State == EAS_Arg ? EAS_RValue : EAS_Failure) {}
+  EmplaceableArg(EmplaceableArg &X)
+      : State(X.State == EAS_Arg ? EAS_LValue : EAS_Failure) {}
+
+  explicit EmplaceableArg(bool) : State(EAS_Arg) {}
+
+private:
+  EmplaceableArg &operator=(EmplaceableArg &&) = delete;
+  EmplaceableArg &operator=(const EmplaceableArg &) = delete;
+};
+
+enum EmplaceableState { ES_Emplaced, ES_Moved };
+struct Emplaceable {
+  EmplaceableArg<0> A0;
+  EmplaceableArg<1> A1;
+  EmplaceableArg<2> A2;
+  EmplaceableArg<3> A3;
+  EmplaceableState State;
+
+  Emplaceable() : State(ES_Emplaced) {}
+
+  template <class A0Ty>
+  explicit Emplaceable(A0Ty &&A0)
+      : A0(std::forward<A0Ty>(A0)), State(ES_Emplaced) {}
+
+  template <class A0Ty, class A1Ty>
+  Emplaceable(A0Ty &&A0, A1Ty &&A1)
+      : A0(std::forward<A0Ty>(A0)), A1(std::forward<A1Ty>(A1)),
+        State(ES_Emplaced) {}
+
+  template <class A0Ty, class A1Ty, class A2Ty>
+  Emplaceable(A0Ty &&A0, A1Ty &&A1, A2Ty &&A2)
+      : A0(std::forward<A0Ty>(A0)), A1(std::forward<A1Ty>(A1)),
+        A2(std::forward<A2Ty>(A2)), State(ES_Emplaced) {}
+
+  template <class A0Ty, class A1Ty, class A2Ty, class A3Ty>
+  Emplaceable(A0Ty &&A0, A1Ty &&A1, A2Ty &&A2, A3Ty &&A3)
+      : A0(std::forward<A0Ty>(A0)), A1(std::forward<A1Ty>(A1)),
+        A2(std::forward<A2Ty>(A2)), A3(std::forward<A3Ty>(A3)),
+        State(ES_Emplaced) {}
+
+  Emplaceable(Emplaceable &&) : State(ES_Moved) {}
+  Emplaceable &operator=(Emplaceable &&) {
+    State = ES_Moved;
+    return *this;
+  }
+
+private:
+  Emplaceable(const Emplaceable &) = delete;
+  Emplaceable &operator=(const Emplaceable &) = delete;
+};
+
+TEST(SmallVectorTest, EmplaceBack) {
+  EmplaceableArg<0> A0(true);
+  EmplaceableArg<1> A1(true);
+  EmplaceableArg<2> A2(true);
+  EmplaceableArg<3> A3(true);
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back();
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A1.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A2.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A3.State == EAS_Defaulted);
+  }
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back(std::move(A0));
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_RValue);
+    EXPECT_TRUE(back.A1.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A2.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A3.State == EAS_Defaulted);
+  }
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back(A0);
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_LValue);
+    EXPECT_TRUE(back.A1.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A2.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A3.State == EAS_Defaulted);
+  }
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back(A0, A1);
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_LValue);
+    EXPECT_TRUE(back.A1.State == EAS_LValue);
+    EXPECT_TRUE(back.A2.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A3.State == EAS_Defaulted);
+  }
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back(std::move(A0), std::move(A1));
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_RValue);
+    EXPECT_TRUE(back.A1.State == EAS_RValue);
+    EXPECT_TRUE(back.A2.State == EAS_Defaulted);
+    EXPECT_TRUE(back.A3.State == EAS_Defaulted);
+  }
+  {
+    SmallVector<Emplaceable, 3> V;
+    Emplaceable &back = V.emplace_back(std::move(A0), A1, std::move(A2), A3);
+    EXPECT_TRUE(&back == &V.back());
+    EXPECT_TRUE(V.size() == 1);
+    EXPECT_TRUE(back.State == ES_Emplaced);
+    EXPECT_TRUE(back.A0.State == EAS_RValue);
+    EXPECT_TRUE(back.A1.State == EAS_LValue);
+    EXPECT_TRUE(back.A2.State == EAS_RValue);
+    EXPECT_TRUE(back.A3.State == EAS_LValue);
+  }
+  {
+    SmallVector<int, 1> V;
+    V.emplace_back();
+    V.emplace_back(42);
+    EXPECT_EQ(2U, V.size());
+    EXPECT_EQ(0, V[0]);
+    EXPECT_EQ(42, V[1]);
+  }
+}
+
+TEST(SmallVectorTest, DefaultInlinedElements) {
+  SmallVector<int> V;
+  EXPECT_TRUE(V.empty());
+  V.push_back(7);
+  EXPECT_EQ(V[0], 7);
+
+  // Check that at least a couple layers of nested SmallVector<T>'s are allowed
+  // by the default inline elements policy. This pattern happens in practice
+  // with some frequency, and it seems fairly harmless even though each layer of
+  // SmallVector's will grow the total sizeof by a vector header beyond the
+  // "preferred" maximum sizeof.
+  SmallVector<SmallVector<SmallVector<int>>> NestedV;
+  NestedV.emplace_back().emplace_back().emplace_back(42);
+  EXPECT_EQ(NestedV[0][0][0], 42);
+}
+
+template <class VectorT>
+class SmallVectorReferenceInvalidationTest : public SmallVectorTestBase {
+protected:
+  const char *AssertionMessage =
+      "Attempting to reference an element of the vector in an operation \" "
+      "\"that invalidates it";
+
+  VectorT V;
+
+  template <typename T, unsigned N>
+  static unsigned NumBuiltinElts(const SmallVector<T, N> &) {
+    return N;
+  }
+
+  template <class T> static bool isValueType() {
+    return std::is_same<T, typename VectorT::value_type>::value;
+  }
+
+  void SetUp() override {
+    SmallVectorTestBase::SetUp();
+
+    // Fill up the small size so that insertions move the elements.
+    for (int I = 0, E = NumBuiltinElts(V); I != E; ++I)
+      V.emplace_back(I + 1);
+  }
+};
+
+// Test one type that's trivially copyable (int) and one that isn't
+// (Constructable) since reference invalidation may be fixed differently for
+// each.
+using SmallVectorReferenceInvalidationTestTypes =
+    ::testing::Types<SmallVector<int, 3>, SmallVector<Constructable, 3>>;
+
+TYPED_TEST_SUITE(SmallVectorReferenceInvalidationTest,
+                 SmallVectorReferenceInvalidationTestTypes, );
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, PushBack) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  int N = this->NumBuiltinElts(V);
+
+  // Push back a reference to last element when growing from small storage.
+  V.push_back(V.back());
+  EXPECT_EQ(N, V.back());
+
+  // Check that the old value is still there (not moved away).
+  EXPECT_EQ(N, V[V.size() - 2]);
+
+  // Fill storage again.
+  V.back() = V.size();
+  while (V.size() < V.capacity())
+    V.push_back(V.size() + 1);
+
+  // Push back a reference to last element when growing from large storage.
+  V.push_back(V.back());
+  EXPECT_EQ(int(V.size()) - 1, V.back());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, PushBackMoved) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  int N = this->NumBuiltinElts(V);
+
+  // Push back a reference to last element when growing from small storage.
+  V.push_back(std::move(V.back()));
+  EXPECT_EQ(N, V.back());
+  if (this->template isValueType<Constructable>()) {
+    // Check that the value was moved (not copied).
+    EXPECT_EQ(0, V[V.size() - 2]);
+  }
+
+  // Fill storage again.
+  V.back() = V.size();
+  while (V.size() < V.capacity())
+    V.push_back(V.size() + 1);
+
+  // Push back a reference to last element when growing from large storage.
+  V.push_back(std::move(V.back()));
+
+  // Check the values.
+  EXPECT_EQ(int(V.size()) - 1, V.back());
+  if (this->template isValueType<Constructable>()) {
+    // Check the value got moved out.
+    EXPECT_EQ(0, V[V.size() - 2]);
+  }
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, Resize) {
+  auto &V = this->V;
+  (void)V;
+  int N = this->NumBuiltinElts(V);
+  V.resize(N + 1, V.back());
+  EXPECT_EQ(N, V.back());
+
+  // Resize to add enough elements that V will grow again. If reference
+  // invalidation breaks in the future, sanitizers should be able to catch a
+  // use-after-free here.
+  V.resize(V.capacity() + 1, V.front());
+  EXPECT_EQ(1, V.back());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, Append) {
+  auto &V = this->V;
+  (void)V;
+  V.append(1, V.back());
+  int N = this->NumBuiltinElts(V);
+  EXPECT_EQ(N, V[N - 1]);
+
+  // Append enough more elements that V will grow again. This tests growing
+  // when already in large mode.
+  //
+  // If reference invalidation breaks in the future, sanitizers should be able
+  // to catch a use-after-free here.
+  V.append(V.capacity() - V.size() + 1, V.front());
+  EXPECT_EQ(1, V.back());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, AppendRange) {
+  auto &V = this->V;
+  (void)V;
+#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
+  EXPECT_DEATH(V.append(V.begin(), V.begin() + 1), this->AssertionMessage);
+
+  ASSERT_EQ(3u, this->NumBuiltinElts(V));
+  ASSERT_EQ(3u, V.size());
+  V.pop_back();
+  ASSERT_EQ(2u, V.size());
+
+  // Confirm this checks for growth when there's more than one element
+  // appended.
+  EXPECT_DEATH(V.append(V.begin(), V.end()), this->AssertionMessage);
+#endif
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, Assign) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  (void)V;
+  int N = this->NumBuiltinElts(V);
+  ASSERT_EQ(unsigned(N), V.size());
+  ASSERT_EQ(unsigned(N), V.capacity());
+
+  // Check assign that shrinks in small mode.
+  V.assign(1, V.back());
+  EXPECT_EQ(1u, V.size());
+  EXPECT_EQ(N, V[0]);
+
+  // Check assign that grows within small mode.
+  ASSERT_LT(V.size(), V.capacity());
+  V.assign(V.capacity(), V.back());
+  for (int I = 0, E = V.size(); I != E; ++I) {
+    EXPECT_EQ(N, V[I]);
+
+    // Reset to [1, 2, ...].
+    V[I] = I + 1;
+  }
+
+  // Check assign that grows to large mode.
+  ASSERT_EQ(2, V[1]);
+  V.assign(V.capacity() + 1, V[1]);
+  for (int I = 0, E = V.size(); I != E; ++I) {
+    EXPECT_EQ(2, V[I]);
+
+    // Reset to [1, 2, ...].
+    V[I] = I + 1;
+  }
+
+  // Check assign that shrinks in large mode.
+  V.assign(1, V[1]);
+  EXPECT_EQ(2, V[0]);
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, AssignRange) {
+  auto &V = this->V;
+#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
+  EXPECT_DEATH(V.assign(V.begin(), V.end()), this->AssertionMessage);
+  EXPECT_DEATH(V.assign(V.begin(), V.end() - 1), this->AssertionMessage);
+#endif
+  V.assign(V.begin(), V.begin());
+  EXPECT_TRUE(V.empty());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, Insert) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  (void)V;
+
+  // Insert a reference to the back (not at end() or else insert delegates to
+  // push_back()), growing out of small mode. Confirm the value was copied out
+  // (moving out Constructable sets it to 0).
+  V.insert(V.begin(), V.back());
+  EXPECT_EQ(int(V.size() - 1), V.front());
+  EXPECT_EQ(int(V.size() - 1), V.back());
+
+  // Fill up the vector again.
+  while (V.size() < V.capacity())
+    V.push_back(V.size() + 1);
+
+  // Grow again from large storage to large storage.
+  V.insert(V.begin(), V.back());
+  EXPECT_EQ(int(V.size() - 1), V.front());
+  EXPECT_EQ(int(V.size() - 1), V.back());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, InsertMoved) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  (void)V;
+
+  // Insert a reference to the back (not at end() or else insert delegates to
+  // push_back()), growing out of small mode. Confirm the value was copied out
+  // (moving out Constructable sets it to 0).
+  V.insert(V.begin(), std::move(V.back()));
+  EXPECT_EQ(int(V.size() - 1), V.front());
+  if (this->template isValueType<Constructable>()) {
+    // Check the value got moved out.
+    EXPECT_EQ(0, V.back());
+  }
+
+  // Fill up the vector again.
+  while (V.size() < V.capacity())
+    V.push_back(V.size() + 1);
+
+  // Grow again from large storage to large storage.
+  V.insert(V.begin(), std::move(V.back()));
+  EXPECT_EQ(int(V.size() - 1), V.front());
+  if (this->template isValueType<Constructable>()) {
+    // Check the value got moved out.
+    EXPECT_EQ(0, V.back());
+  }
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, InsertN) {
+  auto &V = this->V;
+  (void)V;
+
+  // Cover NumToInsert <= this->end() - I.
+  V.insert(V.begin() + 1, 1, V.back());
+  int N = this->NumBuiltinElts(V);
+  EXPECT_EQ(N, V[1]);
+
+  // Cover NumToInsert > this->end() - I, inserting enough elements that V will
+  // also grow again; V.capacity() will be more elements than necessary but
+  // it's a simple way to cover both conditions.
+  //
+  // If reference invalidation breaks in the future, sanitizers should be able
+  // to catch a use-after-free here.
+  V.insert(V.begin(), V.capacity(), V.front());
+  EXPECT_EQ(1, V.front());
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, InsertRange) {
+  auto &V = this->V;
+  (void)V;
+#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
+  EXPECT_DEATH(V.insert(V.begin(), V.begin(), V.begin() + 1),
+               this->AssertionMessage);
+
+  ASSERT_EQ(3u, this->NumBuiltinElts(V));
+  ASSERT_EQ(3u, V.size());
+  V.pop_back();
+  ASSERT_EQ(2u, V.size());
+
+  // Confirm this checks for growth when there's more than one element
+  // inserted.
+  EXPECT_DEATH(V.insert(V.begin(), V.begin(), V.end()), this->AssertionMessage);
+#endif
+}
+
+TYPED_TEST(SmallVectorReferenceInvalidationTest, EmplaceBack) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  int N = this->NumBuiltinElts(V);
+
+  // Push back a reference to last element when growing from small storage.
+  V.emplace_back(V.back());
+  EXPECT_EQ(N, V.back());
+
+  // Check that the old value is still there (not moved away).
+  EXPECT_EQ(N, V[V.size() - 2]);
+
+  // Fill storage again.
+  V.back() = V.size();
+  while (V.size() < V.capacity())
+    V.push_back(V.size() + 1);
+
+  // Push back a reference to last element when growing from large storage.
+  V.emplace_back(V.back());
+  EXPECT_EQ(int(V.size()) - 1, V.back());
+}
+
+template <class VectorT>
+class SmallVectorInternalReferenceInvalidationTest
+    : public SmallVectorTestBase {
+protected:
+  const char *AssertionMessage =
+      "Attempting to reference an element of the vector in an operation \" "
+      "\"that invalidates it";
+
+  VectorT V;
+
+  template <typename T, unsigned N>
+  static unsigned NumBuiltinElts(const SmallVector<T, N> &) {
+    return N;
+  }
+
+  void SetUp() override {
+    SmallVectorTestBase::SetUp();
+
+    // Fill up the small size so that insertions move the elements.
+    for (int I = 0, E = NumBuiltinElts(V); I != E; ++I)
+      V.emplace_back(I + 1, I + 1);
+  }
+};
+
+// Test pairs of the same types from SmallVectorReferenceInvalidationTestTypes.
+using SmallVectorInternalReferenceInvalidationTestTypes =
+    ::testing::Types<SmallVector<std::pair<int, int>, 3>,
+                     SmallVector<std::pair<Constructable, Constructable>, 3>>;
+
+TYPED_TEST_SUITE(SmallVectorInternalReferenceInvalidationTest,
+                 SmallVectorInternalReferenceInvalidationTestTypes, );
+
+TYPED_TEST(SmallVectorInternalReferenceInvalidationTest, EmplaceBack) {
+  // Note: setup adds [1, 2, ...] to V until it's at capacity in small mode.
+  auto &V = this->V;
+  int N = this->NumBuiltinElts(V);
+
+  // Push back a reference to last element when growing from small storage.
+  V.emplace_back(V.back().first, V.back().second);
+  EXPECT_EQ(N, V.back().first);
+  EXPECT_EQ(N, V.back().second);
+
+  // Check that the old value is still there (not moved away).
+  EXPECT_EQ(N, V[V.size() - 2].first);
+  EXPECT_EQ(N, V[V.size() - 2].second);
+
+  // Fill storage again.
+  V.back().first = V.back().second = V.size();
+  while (V.size() < V.capacity())
+    V.emplace_back(V.size() + 1, V.size() + 1);
+
+  // Push back a reference to last element when growing from large storage.
+  V.emplace_back(V.back().first, V.back().second);
+  EXPECT_EQ(int(V.size()) - 1, V.back().first);
+  EXPECT_EQ(int(V.size()) - 1, V.back().second);
+}
+
+} // end namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/StringMapTest.cpp b/wpiutil/src/test/native/cpp/llvm/StringMapTest.cpp
new file mode 100644
index 0000000..71baa20
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/StringMapTest.cpp
@@ -0,0 +1,622 @@
+//===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/StringMap.h"
+#include "gtest/gtest.h"
+#include <algorithm>
+#include <limits>
+#include <tuple>
+using namespace wpi;
+
+namespace {
+
+// Test fixture
+class StringMapTest : public testing::Test {
+protected:
+  StringMap<uint32_t> testMap;
+
+  static const char testKey[];
+  static const uint32_t testValue;
+  static const char* testKeyFirst;
+  static size_t testKeyLength;
+  static const std::string testKeyStr;
+
+  void assertEmptyMap() {
+    // Size tests
+    EXPECT_EQ(0u, testMap.size());
+    EXPECT_TRUE(testMap.empty());
+
+    // Iterator tests
+    EXPECT_TRUE(testMap.begin() == testMap.end());
+
+    // Lookup tests
+    EXPECT_EQ(0u, testMap.count(testKey));
+    EXPECT_EQ(0u, testMap.count(std::string_view(testKeyFirst, testKeyLength)));
+    EXPECT_EQ(0u, testMap.count(testKeyStr));
+    EXPECT_TRUE(testMap.find(testKey) == testMap.end());
+    EXPECT_TRUE(testMap.find(std::string_view(testKeyFirst, testKeyLength)) == 
+                testMap.end());
+    EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end());
+  }
+
+  void assertSingleItemMap() {
+    // Size tests
+    EXPECT_EQ(1u, testMap.size());
+    EXPECT_FALSE(testMap.begin() == testMap.end());
+    EXPECT_FALSE(testMap.empty());
+
+    // Iterator tests
+    StringMap<uint32_t>::iterator it = testMap.begin();
+    EXPECT_STREQ(testKey, it->first().data());
+    EXPECT_EQ(testValue, it->second);
+    ++it;
+    EXPECT_TRUE(it == testMap.end());
+
+    // Lookup tests
+    EXPECT_EQ(1u, testMap.count(testKey));
+    EXPECT_EQ(1u, testMap.count(std::string_view(testKeyFirst, testKeyLength)));
+    EXPECT_EQ(1u, testMap.count(testKeyStr));
+    EXPECT_TRUE(testMap.find(testKey) == testMap.begin());
+    EXPECT_TRUE(testMap.find(std::string_view(testKeyFirst, testKeyLength)) == 
+                testMap.begin());
+    EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin());
+  }
+};
+
+const char StringMapTest::testKey[] = "key";
+const uint32_t StringMapTest::testValue = 1u;
+const char* StringMapTest::testKeyFirst = testKey;
+size_t StringMapTest::testKeyLength = sizeof(testKey) - 1;
+const std::string StringMapTest::testKeyStr(testKey);
+
+struct CountCopyAndMove {
+  CountCopyAndMove() = default;
+  CountCopyAndMove(const CountCopyAndMove &) { copy = 1; }
+  CountCopyAndMove(CountCopyAndMove &&) { move = 1; }
+  void operator=(const CountCopyAndMove &) { ++copy; }
+  void operator=(CountCopyAndMove &&) { ++move; }
+  int copy = 0;
+  int move = 0;
+};
+
+// Empty map tests.
+TEST_F(StringMapTest, EmptyMapTest) {
+  assertEmptyMap();
+}
+
+// Constant map tests.
+TEST_F(StringMapTest, ConstEmptyMapTest) {
+  const StringMap<uint32_t>& constTestMap = testMap;
+
+  // Size tests
+  EXPECT_EQ(0u, constTestMap.size());
+  EXPECT_TRUE(constTestMap.empty());
+
+  // Iterator tests
+  EXPECT_TRUE(constTestMap.begin() == constTestMap.end());
+
+  // Lookup tests
+  EXPECT_EQ(0u, constTestMap.count(testKey));
+  EXPECT_EQ(0u, constTestMap.count(std::string_view(testKeyFirst, testKeyLength)));
+  EXPECT_EQ(0u, constTestMap.count(testKeyStr));
+  EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end());
+  EXPECT_TRUE(constTestMap.find(std::string_view(testKeyFirst, testKeyLength)) ==
+              constTestMap.end());
+  EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end());
+}
+
+// initializer_list ctor test; also implicitly tests initializer_list and
+// iterator overloads of insert().
+TEST_F(StringMapTest, InitializerListCtor) {
+  testMap = StringMap<uint32_t>({{"key", 1}});
+  assertSingleItemMap();
+}
+
+// A map with a single entry.
+TEST_F(StringMapTest, SingleEntryMapTest) {
+  testMap[testKey] = testValue;
+  assertSingleItemMap();
+}
+
+// Test clear() method.
+TEST_F(StringMapTest, ClearTest) {
+  testMap[testKey] = testValue;
+  testMap.clear();
+  assertEmptyMap();
+}
+
+// Test erase(iterator) method.
+TEST_F(StringMapTest, EraseIteratorTest) {
+  testMap[testKey] = testValue;
+  testMap.erase(testMap.begin());
+  assertEmptyMap();
+}
+
+// Test erase(value) method.
+TEST_F(StringMapTest, EraseValueTest) {
+  testMap[testKey] = testValue;
+  testMap.erase(testKey);
+  assertEmptyMap();
+}
+
+// Test inserting two values and erasing one.
+TEST_F(StringMapTest, InsertAndEraseTest) {
+  testMap[testKey] = testValue;
+  testMap["otherKey"] = 2;
+  testMap.erase("otherKey");
+  assertSingleItemMap();
+}
+
+TEST_F(StringMapTest, SmallFullMapTest) {
+  // StringMap has a tricky corner case when the map is small (<8 buckets) and
+  // it fills up through a balanced pattern of inserts and erases. This can
+  // lead to inf-loops in some cases (PR13148) so we test it explicitly here.
+  wpi::StringMap<int> Map(2);
+
+  Map["eins"] = 1;
+  Map["zwei"] = 2;
+  Map["drei"] = 3;
+  Map.erase("drei");
+  Map.erase("eins");
+  Map["veir"] = 4;
+  Map["funf"] = 5;
+
+  EXPECT_EQ(3u, Map.size());
+  EXPECT_EQ(0, Map.lookup("eins"));
+  EXPECT_EQ(2, Map.lookup("zwei"));
+  EXPECT_EQ(0, Map.lookup("drei"));
+  EXPECT_EQ(4, Map.lookup("veir"));
+  EXPECT_EQ(5, Map.lookup("funf"));
+}
+
+TEST_F(StringMapTest, CopyCtorTest) {
+  wpi::StringMap<int> Map;
+
+  Map["eins"] = 1;
+  Map["zwei"] = 2;
+  Map["drei"] = 3;
+  Map.erase("drei");
+  Map.erase("eins");
+  Map["veir"] = 4;
+  Map["funf"] = 5;
+
+  EXPECT_EQ(3u, Map.size());
+  EXPECT_EQ(0, Map.lookup("eins"));
+  EXPECT_EQ(2, Map.lookup("zwei"));
+  EXPECT_EQ(0, Map.lookup("drei"));
+  EXPECT_EQ(4, Map.lookup("veir"));
+  EXPECT_EQ(5, Map.lookup("funf"));
+
+  wpi::StringMap<int> Map2(Map);
+  EXPECT_EQ(3u, Map2.size());
+  EXPECT_EQ(0, Map2.lookup("eins"));
+  EXPECT_EQ(2, Map2.lookup("zwei"));
+  EXPECT_EQ(0, Map2.lookup("drei"));
+  EXPECT_EQ(4, Map2.lookup("veir"));
+  EXPECT_EQ(5, Map2.lookup("funf"));
+}
+
+// A more complex iteration test.
+TEST_F(StringMapTest, IterationTest) {
+  bool visited[100];
+
+  // Insert 100 numbers into the map
+  for (int i = 0; i < 100; ++i) {
+    std::stringstream ss;
+    ss << "key_" << i;
+    testMap[ss.str()] = i;
+    visited[i] = false;
+  }
+
+  // Iterate over all numbers and mark each one found.
+  for (StringMap<uint32_t>::iterator it = testMap.begin();
+      it != testMap.end(); ++it) {
+    std::stringstream ss;
+    ss << "key_" << it->second;
+    ASSERT_STREQ(ss.str().c_str(), it->first().data());
+    visited[it->second] = true;
+  }
+
+  // Ensure every number was visited.
+  for (int i = 0; i < 100; ++i) {
+    ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited";
+  }
+}
+
+// Test StringMapEntry::Create() method.
+TEST_F(StringMapTest, StringMapEntryTest) {
+  MallocAllocator Allocator;
+  StringMap<uint32_t>::value_type *entry =
+      StringMap<uint32_t>::value_type::Create(
+          std::string_view(testKeyFirst, testKeyLength), Allocator, 1u);
+  EXPECT_STREQ(testKey, entry->first().data());
+  EXPECT_EQ(1u, entry->second);
+  entry->Destroy(Allocator);
+}
+
+// Test insert() method.
+TEST_F(StringMapTest, InsertTest) {
+  SCOPED_TRACE("InsertTest");
+  testMap.insert(
+      StringMap<uint32_t>::value_type::Create(
+          std::string_view(testKeyFirst, testKeyLength),
+          testMap.getAllocator(), 1u));
+  assertSingleItemMap();
+}
+
+// Test insert(pair<K, V>) method
+TEST_F(StringMapTest, InsertPairTest) {
+  bool Inserted;
+  StringMap<uint32_t>::iterator NewIt;
+  std::tie(NewIt, Inserted) =
+      testMap.insert(std::make_pair(testKeyFirst, testValue));
+  EXPECT_EQ(1u, testMap.size());
+  EXPECT_EQ(testValue, testMap[testKeyFirst]);
+  EXPECT_EQ(testKeyFirst, NewIt->first());
+  EXPECT_EQ(testValue, NewIt->second);
+  EXPECT_TRUE(Inserted);
+
+  StringMap<uint32_t>::iterator ExistingIt;
+  std::tie(ExistingIt, Inserted) =
+      testMap.insert(std::make_pair(testKeyFirst, testValue + 1));
+  EXPECT_EQ(1u, testMap.size());
+  EXPECT_EQ(testValue, testMap[testKeyFirst]);
+  EXPECT_FALSE(Inserted);
+  EXPECT_EQ(NewIt, ExistingIt);
+}
+
+// Test insert(pair<K, V>) method when rehashing occurs
+TEST_F(StringMapTest, InsertRehashingPairTest) {
+  // Check that the correct iterator is returned when the inserted element is
+  // moved to a different bucket during internal rehashing. This depends on
+  // the particular key, and the implementation of StringMap and HashString.
+  // Changes to those might result in this test not actually checking that.
+  StringMap<uint32_t> t(0);
+  EXPECT_EQ(0u, t.getNumBuckets());
+
+  StringMap<uint32_t>::iterator It =
+    t.insert(std::make_pair("abcdef", 42)).first;
+  EXPECT_EQ(16u, t.getNumBuckets());
+  EXPECT_EQ("abcdef", It->first());
+  EXPECT_EQ(42u, It->second);
+}
+
+TEST_F(StringMapTest, InsertOrAssignTest) {
+  struct A : CountCopyAndMove {
+    A(int v) : v(v) {}
+    int v;
+  };
+  StringMap<A> t(0);
+
+  auto try1 = t.insert_or_assign("A", A(1));
+  EXPECT_TRUE(try1.second);
+  EXPECT_EQ(1, try1.first->second.v);
+  EXPECT_EQ(1, try1.first->second.move);
+
+  auto try2 = t.insert_or_assign("A", A(2));
+  EXPECT_FALSE(try2.second);
+  EXPECT_EQ(2, try2.first->second.v);
+  EXPECT_EQ(2, try1.first->second.move);
+
+  EXPECT_EQ(try1.first, try2.first);
+  EXPECT_EQ(0, try1.first->second.copy);
+}
+
+TEST_F(StringMapTest, IterMapKeysSmallVector) {
+  StringMap<int> Map;
+  Map["A"] = 1;
+  Map["B"] = 2;
+  Map["C"] = 3;
+  Map["D"] = 3;
+
+  auto Keys = to_vector<4>(Map.keys());
+  std::sort(Keys.begin(), Keys.end());
+
+  SmallVector<std::string_view, 4> Expected = {"A", "B", "C", "D"};
+  EXPECT_EQ(Expected, Keys);
+}
+
+// Create a non-default constructable value
+struct StringMapTestStruct {
+  StringMapTestStruct(int i) : i(i) {}
+  StringMapTestStruct() = delete;
+  int i;
+};
+
+TEST_F(StringMapTest, NonDefaultConstructable) {
+  StringMap<StringMapTestStruct> t;
+  t.insert(std::make_pair("Test", StringMapTestStruct(123)));
+  StringMap<StringMapTestStruct>::iterator iter = t.find("Test");
+  ASSERT_NE(iter, t.end());
+  ASSERT_EQ(iter->second.i, 123);
+}
+
+struct Immovable {
+  Immovable() {}
+  Immovable(Immovable&&) = delete; // will disable the other special members
+};
+
+struct MoveOnly {
+  int i;
+  MoveOnly(int i) : i(i) {}
+  MoveOnly(const Immovable&) : i(0) {}
+  MoveOnly(MoveOnly &&RHS) : i(RHS.i) {}
+  MoveOnly &operator=(MoveOnly &&RHS) {
+    i = RHS.i;
+    return *this;
+  }
+
+private:
+  MoveOnly(const MoveOnly &) = delete;
+  MoveOnly &operator=(const MoveOnly &) = delete;
+};
+
+TEST_F(StringMapTest, MoveOnly) {
+  StringMap<MoveOnly> t;
+  t.insert(std::make_pair("Test", MoveOnly(42)));
+  std::string_view Key = "Test";
+  StringMapEntry<MoveOnly>::Create(Key, t.getAllocator(), MoveOnly(42))
+      ->Destroy(t.getAllocator());
+}
+
+TEST_F(StringMapTest, CtorArg) {
+  std::string_view Key = "Test";
+  MallocAllocator Allocator;
+  StringMapEntry<MoveOnly>::Create(Key, Allocator, Immovable())
+      ->Destroy(Allocator);
+}
+
+TEST_F(StringMapTest, MoveConstruct) {
+  StringMap<int> A;
+  A["x"] = 42;
+  StringMap<int> B = std::move(A);
+  ASSERT_EQ(A.size(), 0u);
+  ASSERT_EQ(B.size(), 1u);
+  ASSERT_EQ(B["x"], 42);
+  ASSERT_EQ(B.count("y"), 0u);
+}
+
+TEST_F(StringMapTest, MoveAssignment) {
+  StringMap<int> A;
+  A["x"] = 42;
+  StringMap<int> B;
+  B["y"] = 117;
+  A = std::move(B);
+  ASSERT_EQ(A.size(), 1u);
+  ASSERT_EQ(B.size(), 0u);
+  ASSERT_EQ(A["y"], 117);
+  ASSERT_EQ(B.count("x"), 0u);
+}
+
+TEST_F(StringMapTest, EqualEmpty) {
+  StringMap<int> A;
+  StringMap<int> B;
+  ASSERT_TRUE(A == B);
+  ASSERT_FALSE(A != B);
+  ASSERT_TRUE(A == A); // self check
+}
+
+TEST_F(StringMapTest, EqualWithValues) {
+  StringMap<int> A;
+  A["A"] = 1;
+  A["B"] = 2;
+  A["C"] = 3;
+  A["D"] = 3;
+
+  StringMap<int> B;
+  B["A"] = 1;
+  B["B"] = 2;
+  B["C"] = 3;
+  B["D"] = 3;
+
+  ASSERT_TRUE(A == B);
+  ASSERT_TRUE(B == A);
+  ASSERT_FALSE(A != B);
+  ASSERT_FALSE(B != A);
+  ASSERT_TRUE(A == A); // self check
+}
+
+TEST_F(StringMapTest, NotEqualMissingKeys) {
+  StringMap<int> A;
+  A["A"] = 1;
+  A["B"] = 2;
+
+  StringMap<int> B;
+  B["A"] = 1;
+  B["B"] = 2;
+  B["C"] = 3;
+  B["D"] = 3;
+
+  ASSERT_FALSE(A == B);
+  ASSERT_FALSE(B == A);
+  ASSERT_TRUE(A != B);
+  ASSERT_TRUE(B != A);
+}
+
+TEST_F(StringMapTest, NotEqualWithDifferentValues) {
+  StringMap<int> A;
+  A["A"] = 1;
+  A["B"] = 2;
+  A["C"] = 100;
+  A["D"] = 3;
+
+  StringMap<int> B;
+  B["A"] = 1;
+  B["B"] = 2;
+  B["C"] = 3;
+  B["D"] = 3;
+
+  ASSERT_FALSE(A == B);
+  ASSERT_FALSE(B == A);
+  ASSERT_TRUE(A != B);
+  ASSERT_TRUE(B != A);
+}
+
+struct Countable {
+  int &InstanceCount;
+  int Number;
+  Countable(int Number, int &InstanceCount)
+      : InstanceCount(InstanceCount), Number(Number) {
+    ++InstanceCount;
+  }
+  Countable(Countable &&C) : InstanceCount(C.InstanceCount), Number(C.Number) {
+    ++InstanceCount;
+    C.Number = -1;
+  }
+  Countable(const Countable &C)
+      : InstanceCount(C.InstanceCount), Number(C.Number) {
+    ++InstanceCount;
+  }
+  Countable &operator=(Countable C) {
+    Number = C.Number;
+    return *this;
+  }
+  ~Countable() { --InstanceCount; }
+};
+
+TEST_F(StringMapTest, MoveDtor) {
+  int InstanceCount = 0;
+  StringMap<Countable> A;
+  A.insert(std::make_pair("x", Countable(42, InstanceCount)));
+  ASSERT_EQ(InstanceCount, 1);
+  auto I = A.find("x");
+  ASSERT_NE(I, A.end());
+  ASSERT_EQ(I->second.Number, 42);
+
+  StringMap<Countable> B;
+  B = std::move(A);
+  ASSERT_EQ(InstanceCount, 1);
+  ASSERT_TRUE(A.empty());
+  I = B.find("x");
+  ASSERT_NE(I, B.end());
+  ASSERT_EQ(I->second.Number, 42);
+
+  B = StringMap<Countable>();
+  ASSERT_EQ(InstanceCount, 0);
+  ASSERT_TRUE(B.empty());
+}
+
+namespace {
+// Simple class that counts how many moves and copy happens when growing a map
+struct CountCtorCopyAndMove {
+  static unsigned Ctor;
+  static unsigned Move;
+  static unsigned Copy;
+  int Data = 0;
+  CountCtorCopyAndMove(int Data) : Data(Data) { Ctor++; }
+  CountCtorCopyAndMove() { Ctor++; }
+
+  CountCtorCopyAndMove(const CountCtorCopyAndMove &) { Copy++; }
+  CountCtorCopyAndMove &operator=(const CountCtorCopyAndMove &) {
+    Copy++;
+    return *this;
+  }
+  CountCtorCopyAndMove(CountCtorCopyAndMove &&) { Move++; }
+  CountCtorCopyAndMove &operator=(const CountCtorCopyAndMove &&) {
+    Move++;
+    return *this;
+  }
+};
+unsigned CountCtorCopyAndMove::Copy = 0;
+unsigned CountCtorCopyAndMove::Move = 0;
+unsigned CountCtorCopyAndMove::Ctor = 0;
+
+} // anonymous namespace
+
+// Make sure creating the map with an initial size of N actually gives us enough
+// buckets to insert N items without increasing allocation size.
+TEST(StringMapCustomTest, InitialSizeTest) {
+  // 1 is an "edge value", 32 is an arbitrary power of two, and 67 is an
+  // arbitrary prime, picked without any good reason.
+  for (auto Size : {1, 32, 67}) {
+    StringMap<CountCtorCopyAndMove> Map(Size);
+    auto NumBuckets = Map.getNumBuckets();
+    CountCtorCopyAndMove::Move = 0;
+    CountCtorCopyAndMove::Copy = 0;
+    for (int i = 0; i < Size; ++i)
+      Map.insert(std::pair<std::string, CountCtorCopyAndMove>(
+          std::piecewise_construct, std::forward_as_tuple(std::to_string(i)),
+          std::forward_as_tuple(i)));
+    // After the initial move, the map will move the Elts in the Entry.
+    EXPECT_EQ((unsigned)Size * 2, CountCtorCopyAndMove::Move);
+    // We copy once the pair from the Elts vector
+    EXPECT_EQ(0u, CountCtorCopyAndMove::Copy);
+    // Check that the map didn't grow
+    EXPECT_EQ(Map.getNumBuckets(), NumBuckets);
+  }
+}
+
+TEST(StringMapCustomTest, BracketOperatorCtor) {
+  StringMap<CountCtorCopyAndMove> Map;
+  CountCtorCopyAndMove::Ctor = 0;
+  Map["abcd"];
+  EXPECT_EQ(1u, CountCtorCopyAndMove::Ctor);
+  // Test that operator[] does not create a value when it is already in the map
+  CountCtorCopyAndMove::Ctor = 0;
+  Map["abcd"];
+  EXPECT_EQ(0u, CountCtorCopyAndMove::Ctor);
+}
+
+namespace {
+struct NonMoveableNonCopyableType {
+  int Data = 0;
+  NonMoveableNonCopyableType() = default;
+  NonMoveableNonCopyableType(int Data) : Data(Data) {}
+  NonMoveableNonCopyableType(const NonMoveableNonCopyableType &) = delete;
+  NonMoveableNonCopyableType(NonMoveableNonCopyableType &&) = delete;
+};
+}
+
+// Test that we can "emplace" an element in the map without involving map/move
+TEST(StringMapCustomTest, EmplaceTest) {
+  StringMap<NonMoveableNonCopyableType> Map;
+  Map.try_emplace("abcd", 42);
+  EXPECT_EQ(1u, Map.count("abcd"));
+  EXPECT_EQ(42, Map["abcd"].Data);
+}
+
+// Test that StringMapEntryBase can handle size_t wide sizes.
+TEST(StringMapCustomTest, StringMapEntryBaseSize) {
+  size_t LargeValue;
+
+  // Test that the entry can represent max-unsigned.
+  if (sizeof(size_t) <= sizeof(unsigned))
+    LargeValue = std::numeric_limits<unsigned>::max();
+  else
+    LargeValue = std::numeric_limits<unsigned>::max() + 1ULL;
+  StringMapEntryBase LargeBase(LargeValue);
+  EXPECT_EQ(LargeValue, LargeBase.getKeyLength());
+
+  // Test that the entry can hold at least max size_t.
+  LargeValue = std::numeric_limits<size_t>::max();
+  StringMapEntryBase LargerBase(LargeValue);
+  LargeValue = std::numeric_limits<size_t>::max();
+  EXPECT_EQ(LargeValue, LargerBase.getKeyLength());
+}
+
+// Test that StringMapEntry can handle size_t wide sizes.
+TEST(StringMapCustomTest, StringMapEntrySize) {
+  size_t LargeValue;
+
+  // Test that the entry can represent max-unsigned.
+  if (sizeof(size_t) <= sizeof(unsigned))
+    LargeValue = std::numeric_limits<unsigned>::max();
+  else
+    LargeValue = std::numeric_limits<unsigned>::max() + 1ULL;
+  StringMapEntry<int> LargeEntry(LargeValue);
+  std::string_view Key = LargeEntry.getKey();
+  EXPECT_EQ(LargeValue, Key.size());
+
+  // Test that the entry can hold at least max size_t.
+  LargeValue = std::numeric_limits<size_t>::max();
+  StringMapEntry<int> LargerEntry(LargeValue);
+  Key = LargerEntry.getKey();
+  EXPECT_EQ(LargeValue, Key.size());
+}
+
+} // end anonymous namespace
diff --git a/wpiutil/src/test/native/cpp/llvm/SwapByteOrderTest.cpp b/wpiutil/src/test/native/cpp/llvm/SwapByteOrderTest.cpp
new file mode 100644
index 0000000..abacef7
--- /dev/null
+++ b/wpiutil/src/test/native/cpp/llvm/SwapByteOrderTest.cpp
@@ -0,0 +1,210 @@
+//===- unittests/Support/SwapByteOrderTest.cpp - swap byte order test -----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "wpi/SwapByteOrder.h"
+#include "gtest/gtest.h"
+#include <cstdlib>
+#include <ctime>
+using namespace wpi;
+
+#undef max
+
+namespace {
+
+TEST(ByteSwap, Swap_32) {
+  EXPECT_EQ(0x44332211u, ByteSwap_32(0x11223344));
+  EXPECT_EQ(0xDDCCBBAAu, ByteSwap_32(0xAABBCCDD));
+}
+
+TEST(ByteSwap, Swap_64) {
+  EXPECT_EQ(0x8877665544332211ULL, ByteSwap_64(0x1122334455667788LL));
+  EXPECT_EQ(0x1100FFEEDDCCBBAAULL, ByteSwap_64(0xAABBCCDDEEFF0011LL));
+}
+
+// In these first two tests all of the original_uintx values are truncated
+// except for 64. We could avoid this, but there's really no point.
+
+TEST(getSwappedBytes, UnsignedRoundTrip) {
+  // The point of the bit twiddling of magic is to test with and without bits
+  // in every byte.
+  uint64_t value = 1;
+  for (std::size_t i = 0; i <= sizeof(value); ++i) {
+    uint8_t original_uint8 = static_cast<uint8_t>(value);
+    EXPECT_EQ(original_uint8,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_uint8)));
+
+    uint16_t original_uint16 = static_cast<uint16_t>(value);
+    EXPECT_EQ(original_uint16,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_uint16)));
+
+    uint32_t original_uint32 = static_cast<uint32_t>(value);
+    EXPECT_EQ(original_uint32,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_uint32)));
+
+    uint64_t original_uint64 = static_cast<uint64_t>(value);
+    EXPECT_EQ(original_uint64,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_uint64)));
+
+    value = (value << 8) | 0x55; // binary 0101 0101.
+  }
+}
+
+TEST(getSwappedBytes, SignedRoundTrip) {
+  // The point of the bit twiddling of magic is to test with and without bits
+  // in every byte.
+  uint64_t value = 1;
+  for (std::size_t i = 0; i <= sizeof(value); ++i) {
+    int8_t original_int8 = static_cast<int8_t>(value);
+    EXPECT_EQ(original_int8,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
+
+    int16_t original_int16 = static_cast<int16_t>(value);
+    EXPECT_EQ(original_int16,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
+
+    int32_t original_int32 = static_cast<int32_t>(value);
+    EXPECT_EQ(original_int32,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
+
+    int64_t original_int64 = static_cast<int64_t>(value);
+    EXPECT_EQ(original_int64,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
+
+    // Test other sign.
+    value *= -1;
+
+    original_int8 = static_cast<int8_t>(value);
+    EXPECT_EQ(original_int8,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int8)));
+
+    original_int16 = static_cast<int16_t>(value);
+    EXPECT_EQ(original_int16,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int16)));
+
+    original_int32 = static_cast<int32_t>(value);
+    EXPECT_EQ(original_int32,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int32)));
+
+    original_int64 = static_cast<int64_t>(value);
+    EXPECT_EQ(original_int64,
+              sys::getSwappedBytes(sys::getSwappedBytes(original_int64)));
+
+    // Return to normal sign and twiddle.
+    value *= -1;
+    value = (value << 8) | 0x55; // binary 0101 0101.
+  }
+}
+
+TEST(getSwappedBytes, uint8_t) {
+  EXPECT_EQ(uint8_t(0x11), sys::getSwappedBytes(uint8_t(0x11)));
+}
+
+TEST(getSwappedBytes, uint16_t) {
+  EXPECT_EQ(uint16_t(0x1122), sys::getSwappedBytes(uint16_t(0x2211)));
+}
+
+TEST(getSwappedBytes, uint32_t) {
+  EXPECT_EQ(uint32_t(0x11223344), sys::getSwappedBytes(uint32_t(0x44332211)));
+}
+
+TEST(getSwappedBytes, uint64_t) {
+  EXPECT_EQ(uint64_t(0x1122334455667788ULL),
+    sys::getSwappedBytes(uint64_t(0x8877665544332211ULL)));
+}
+
+TEST(getSwappedBytes, int8_t) {
+  EXPECT_EQ(int8_t(0x11), sys::getSwappedBytes(int8_t(0x11)));
+}
+
+TEST(getSwappedBytes, int16_t) {
+  EXPECT_EQ(int16_t(0x1122), sys::getSwappedBytes(int16_t(0x2211)));
+}
+
+TEST(getSwappedBytes, int32_t) {
+  EXPECT_EQ(int32_t(0x11223344), sys::getSwappedBytes(int32_t(0x44332211)));
+}
+
+TEST(getSwappedBytes, int64_t) {
+  EXPECT_EQ(int64_t(0x1122334455667788LL),
+    sys::getSwappedBytes(int64_t(0x8877665544332211LL)));
+}
+
+TEST(getSwappedBytes, float) {
+  EXPECT_EQ(1.79366203433576585078237386661e-43f, sys::getSwappedBytes(-0.0f));
+  // 0x11223344
+  EXPECT_EQ(7.1653228759765625e2f, sys::getSwappedBytes(1.2795344e-28f));
+}
+
+TEST(getSwappedBytes, double) {
+  EXPECT_EQ(6.32404026676795576546008054871e-322, sys::getSwappedBytes(-0.0));
+  // 0x1122334455667788
+  EXPECT_EQ(-7.08687663657301358331704585496e-268,
+    sys::getSwappedBytes(3.84141202447173065923064450234e-226));
+}
+
+TEST(swapByteOrder, uint8_t) {
+  uint8_t value = 0x11;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(uint8_t(0x11), value);
+}
+
+TEST(swapByteOrder, uint16_t) {
+  uint16_t value = 0x2211;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(uint16_t(0x1122), value);
+}
+
+TEST(swapByteOrder, uint32_t) {
+  uint32_t value = 0x44332211;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(uint32_t(0x11223344), value);
+}
+
+TEST(swapByteOrder, uint64_t) {
+  uint64_t value = 0x8877665544332211ULL;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(uint64_t(0x1122334455667788ULL), value);
+}
+
+TEST(swapByteOrder, int8_t) {
+  int8_t value = 0x11;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(int8_t(0x11), value);
+}
+
+TEST(swapByteOrder, int16_t) {
+  int16_t value = 0x2211;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(int16_t(0x1122), value);
+}
+
+TEST(swapByteOrder, int32_t) {
+  int32_t value = 0x44332211;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(int32_t(0x11223344), value);
+}
+
+TEST(swapByteOrder, int64_t) {
+  int64_t value = 0x8877665544332211LL;
+  sys::swapByteOrder(value);
+  EXPECT_EQ(int64_t(0x1122334455667788LL), value);
+}
+
+TEST(swapByteOrder, float) {
+  float value = 7.1653228759765625e2f; // 0x44332211
+  sys::swapByteOrder(value);
+  EXPECT_EQ(1.2795344e-28f, value);
+}
+
+TEST(swapByteOrder, double) {
+  double value = -7.08687663657301358331704585496e-268; // 0x8877665544332211
+  sys::swapByteOrder(value);
+  EXPECT_EQ(3.84141202447173065923064450234e-226, value);
+}
+
+}
diff --git a/wpiutil/src/test/native/cpp/raw_uv_stream_test.cpp b/wpiutil/src/test/native/cpp/raw_uv_stream_test.cpp
deleted file mode 100644
index 985fb8b..0000000
--- a/wpiutil/src/test/native/cpp/raw_uv_stream_test.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/raw_uv_ostream.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"
-
-namespace wpi {
-
-TEST(RawUvStreamTest, BasicWrite) {
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os(bufs, 1024);
-  os << "12";
-  os << "34";
-  ASSERT_EQ(bufs.size(), 1u);
-  ASSERT_EQ(bufs[0].len, 4u);
-  ASSERT_EQ(bufs[0].base[0], '1');
-  ASSERT_EQ(bufs[0].base[1], '2');
-  ASSERT_EQ(bufs[0].base[2], '3');
-  ASSERT_EQ(bufs[0].base[3], '4');
-
-  for (auto& buf : bufs) {
-    buf.Deallocate();
-  }
-}
-
-TEST(RawUvStreamTest, BoundaryWrite) {
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os(bufs, 4);
-  ASSERT_EQ(bufs.size(), 0u);
-  os << "12";
-  ASSERT_EQ(bufs.size(), 1u);
-  os << "34";
-  ASSERT_EQ(bufs.size(), 1u);
-  os << "56";
-  ASSERT_EQ(bufs.size(), 2u);
-
-  for (auto& buf : bufs) {
-    buf.Deallocate();
-  }
-}
-
-TEST(RawUvStreamTest, LargeWrite) {
-  SmallVector<uv::Buffer, 4> bufs;
-  raw_uv_ostream os(bufs, 4);
-  os << "123456";
-  ASSERT_EQ(bufs.size(), 2u);
-  ASSERT_EQ(bufs[1].len, 2u);
-  ASSERT_EQ(bufs[1].base[0], '5');
-
-  for (auto& buf : bufs) {
-    buf.Deallocate();
-  }
-}
-
-TEST(RawUvStreamTest, PrevDataWrite) {
-  SmallVector<uv::Buffer, 4> bufs;
-  bufs.emplace_back(uv::Buffer::Allocate(1024));
-  raw_uv_ostream os(bufs, 1024);
-  os << "1234";
-  ASSERT_EQ(bufs.size(), 2u);
-  ASSERT_EQ(bufs[0].len, 1024u);
-  ASSERT_EQ(bufs[1].len, 4u);
-
-  for (auto& buf : bufs) {
-    buf.Deallocate();
-  }
-}
-
-}  // namespace wpi
diff --git a/wpiutil/src/test/native/cpp/span/test_conversions.cpp b/wpiutil/src/test/native/cpp/span/test_conversions.cpp
deleted file mode 100644
index fa111a7..0000000
--- a/wpiutil/src/test/native/cpp/span/test_conversions.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#if __has_include(<span>)
-#include <span>
-#endif
-#include "wpi/span.h"
-
-#include "gtest/gtest.h"
-
-void func1(wpi::span<const int> x) {}
-#ifdef __cpp_lib_span
-void func2(std::span<const int> x) {}
-#endif
-
-void func4(wpi::span<int> x) {}
-#ifdef __cpp_lib_span
-void func5(std::span<int> x) {}
-#endif
-
-TEST(Span, ConvertStdSpan) {
-  func1(wpi::span<const int>{});
-  func1(wpi::span<int>{});
-#ifdef __cpp_lib_span
-  func1(std::span<const int>{});
-  func1(std::span<int>{});
-#endif
-
-#ifdef __cpp_lib_span
-  func2(wpi::span<const int>{});
-  func2(wpi::span<int>{});
-  func2(std::span<const int>{});
-  func2(std::span<int>{});
-#endif
-
-  //func4(wpi::span<const int>{});
-  func4(wpi::span<int>{});
-#ifdef __cpp_lib_span
-  //func4(std::span<const int>{});
-  func4(std::span<int>{});
-#endif
-
-#ifdef __cpp_lib_span
-  //func5(wpi::span<const int>{});
-  func5(wpi::span<int>{});
-  //func5(std::span<const int>{});
-  func5(std::span<int>{});
-#endif
-}
diff --git a/wpiutil/src/test/native/cpp/span/test_deduction_guides.cpp b/wpiutil/src/test/native/cpp/span/test_deduction_guides.cpp
deleted file mode 100644
index 9851b5e..0000000
--- a/wpiutil/src/test/native/cpp/span/test_deduction_guides.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-
-#include "wpi/span.h"
-
-#include "gtest/gtest.h"
-
-#include <vector>
-
-using wpi::span;
-
-namespace {
-
-template <typename R1, typename R2>
-constexpr bool equal(R1&& r1, R2&& r2)
-{
-    auto first1 = std::begin(r1);
-    const auto last1 = std::end(r1);
-    auto first2 = std::begin(r2);
-    const auto last2 = std::end(r2);
-
-    while (first1 != last1 && first2 != last2) {
-        if (*first1 != *first2) {
-            return false;
-        }
-        ++first1;
-        ++first2;
-    }
-
-    return true;
-}
-
-constexpr bool test_raw_array()
-{
-    int arr[] = {1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<int, 3>>);
-
-    return equal(arr, s);
-}
-
-constexpr bool test_const_raw_array()
-{
-    constexpr int arr[] = {1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<const int, 3>>);
-
-    return equal(arr, s);
-}
-
-constexpr bool test_std_array()
-{
-    auto arr = std::array<int, 3>{1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<int, 3>>);
-
-    return equal(arr, s);
-}
-
-constexpr bool test_const_std_array()
-{
-    const auto arr = std::array<int, 3>{1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<const int, 3>>);
-
-    return equal(arr, s);
-}
-
-bool test_vec()
-{
-    auto arr = std::vector{1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<int>>);
-
-    return equal(arr, s);
-}
-
-bool test_const_vec()
-{
-    const auto arr = std::vector{1, 2, 3};
-    auto s = span{arr};
-    static_assert(std::is_same_v<decltype(s), span<const int>>);
-
-    return equal(arr, s);
-}
-
-}
-
-TEST(Deduction, FromRawArrays)
-{
-    static_assert(test_raw_array());
-    static_assert(test_const_raw_array());
-    static_assert(test_std_array());
-    static_assert(test_const_std_array());
-
-    ASSERT_TRUE(test_std_array());
-    ASSERT_TRUE(test_const_std_array());
-    ASSERT_TRUE(test_vec());
-    ASSERT_TRUE(test_const_vec());
-}
diff --git a/wpiutil/src/test/native/cpp/span/test_span.cpp b/wpiutil/src/test/native/cpp/span/test_span.cpp
deleted file mode 100644
index 7cecfd0..0000000
--- a/wpiutil/src/test/native/cpp/span/test_span.cpp
+++ /dev/null
@@ -1,663 +0,0 @@
-
-#include "wpi/span.h"
-
-#include <algorithm>
-#include <cassert>
-#include <deque>
-#include <initializer_list>
-#include <vector>
-
-#include "gtest/gtest.h"
-
-using wpi::span;
-
-struct base {};
-struct derived : base {};
-
-TEST(Span, DefaultConstruction)
-{
-    static_assert(std::is_nothrow_default_constructible<span<int>>::value, "");
-    static_assert(std::is_nothrow_default_constructible<span<int, 0>>::value,
-                  "");
-    static_assert(!std::is_default_constructible<span<int, 42>>::value, "");
-
-    //SECTION("dynamic size")
-    {
-        constexpr span<int> s{};
-        static_assert(s.size() == 0, "");
-        static_assert(s.data() == nullptr, "");
-        // This causes an ICE on MSVC
-#ifndef _MSC_VER
-        static_assert(s.begin() == s.end(), "");
-#else
-        ASSERT_EQ(s.begin(), s.end());
-#endif
-    }
-
-    //SECTION("fixed size")
-    {
-        constexpr span<int, 0> s{};
-        static_assert(s.size() == 0, "");
-        static_assert(s.data() == nullptr, "");
-#ifndef _MSC_VER
-        static_assert(s.begin() == s.end(), "");
-#else
-        ASSERT_EQ(s.begin(), s.end());
-#endif
-    }
-}
-
-TEST(Span, PointerLengthConstruction)
-{
-    static_assert(std::is_constructible<span<int>, int*, int>::value, "");
-    static_assert(std::is_constructible<span<const int>, int*, int>::value, "");
-    static_assert(
-        std::is_constructible<span<const int>, const int*, int>::value, "");
-
-    static_assert(std::is_constructible<span<int, 42>, int*, int>::value, "");
-    static_assert(std::is_constructible<span<const int, 42>, int*, int>::value,
-                  "");
-    static_assert(
-        std::is_constructible<span<const int, 42>, const int*, int>::value, "");
-
-    //SECTION("dynamic size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int> s(arr, 3);
-
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-
-    //SECTION("fixed size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int, 3> s(arr, 3);
-
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-}
-
-TEST(Span, PointerPointerConstruction)
-{
-    static_assert(std::is_constructible<span<int>, int*, int*>::value, "");
-    static_assert(!std::is_constructible<span<int>, float*, float*>::value, "");
-    static_assert(std::is_constructible<span<int, 42>, int*, int*>::value, "");
-    static_assert(!std::is_constructible<span<int, 42>, float*, float*>::value,
-                  "");
-
-    //SECTION("dynamic size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int> s{arr, arr + 3};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-
-    //SECTION("fixed size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int, 3> s{arr, arr + 3};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-}
-
-TEST(Span, CArrayConstruction)
-{
-    using int_array_t = int[3];
-    using float_array_t = float[3];
-
-    static_assert(std::is_nothrow_constructible<span<int>, int_array_t&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<int>, int_array_t const&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<int>, float_array_t>::value, "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<const int>, int_array_t&>::value,
-        "");
-    static_assert(std::is_nothrow_constructible<span<const int>,
-                                                int_array_t const&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<const int>, float_array_t>::value,
-                  "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<int, 3>, int_array_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<int, 3>, int_array_t const&>::value, "");
-    static_assert(!std::is_constructible<span<int, 3>, float_array_t&>::value,
-                  "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<const int, 3>, int_array_t&>::value,
-        "");
-    static_assert(std::is_nothrow_constructible<span<const int, 3>,
-                                                int_array_t const&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<const int, 3>, float_array_t>::value, "");
-
-    static_assert(!std::is_constructible<span<int, 42>, int_array_t&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<int, 42>, int_array_t const&>::value, "");
-    static_assert(!std::is_constructible<span<int, 42>, float_array_t&>::value,
-                  "");
-
-    static_assert(
-        !std::is_constructible<span<const int, 42>, int_array_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<const int, 42>, int_array_t const&>::value,
-        "");
-    static_assert(
-        !std::is_constructible<span<const int, 42>, float_array_t&>::value, "");
-
-    //SECTION("non-const, dynamic size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int const> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-
-    //SECTION("non-const, static size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        int arr[] = {1, 2, 3};
-        span<int const, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.begin(), std::begin(arr));
-        ASSERT_EQ(s.end(), std::end(arr));
-    }
-}
-
-TEST(Span, StdArrayConstruction)
-{
-    using int_array_t = std::array<int, 3>;
-    using float_array_t = std::array<float, 3>;
-    using zero_array_t = std::array<int, 0>;
-
-    static_assert(std::is_nothrow_constructible<span<int>, int_array_t&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<int>, int_array_t const&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<int>, float_array_t>::value, "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<const int>, int_array_t&>::value,
-        "");
-    static_assert(std::is_nothrow_constructible<span<const int>,
-                                                int_array_t const&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<const int>, float_array_t const&>::value,
-        "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<int, 3>, int_array_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<int, 3>, int_array_t const&>::value, "");
-    static_assert(!std::is_constructible<span<int, 3>, float_array_t>::value,
-                  "");
-
-    static_assert(
-        std::is_nothrow_constructible<span<const int, 3>, int_array_t&>::value,
-        "");
-    static_assert(std::is_nothrow_constructible<span<const int, 3>,
-                                                int_array_t const&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<const int, 3>, float_array_t const&>::value,
-        "");
-
-    static_assert(!std::is_constructible<span<int, 42>, int_array_t&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<int, 42>, int_array_t const&>::value, "");
-    static_assert(
-        !std::is_constructible<span<int, 42>, float_array_t const&>::value, "");
-
-    static_assert(
-        !std::is_constructible<span<const int, 42>, int_array_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<const int, 42>, int_array_t const&>::value,
-        "");
-    static_assert(
-        !std::is_constructible<span<const int, 42>, float_array_t&>::value, "");
-
-    static_assert(std::is_constructible<span<int>, zero_array_t&>::value, "");
-    static_assert(!std::is_constructible<span<int>, const zero_array_t&>::value,
-                  "");
-    static_assert(std::is_constructible<span<const int>, zero_array_t&>::value,
-                  "");
-    static_assert(
-        std::is_constructible<span<const int>, const zero_array_t&>::value, "");
-
-    static_assert(std::is_constructible<span<int, 0>, zero_array_t&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<int, 0>, const zero_array_t&>::value, "");
-    static_assert(
-        std::is_constructible<span<const int, 0>, zero_array_t&>::value, "");
-    static_assert(
-        std::is_constructible<span<const int, 0>, const zero_array_t&>::value,
-        "");
-
-    //SECTION("non-const, dynamic size")
-    {
-        int_array_t arr = {1, 2, 3};
-        span<int> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        int_array_t arr = {1, 2, 3};
-        span<int const> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("non-const, static size")
-    {
-        int_array_t arr = {1, 2, 3};
-        span<int, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        int_array_t arr = {1, 2, 3};
-        span<int const, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-}
-
-TEST(Span, ConstructionFromOtherContainers)
-{
-    using vec_t = std::vector<int>;
-    using deque_t = std::deque<int>;
-
-    static_assert(std::is_constructible<span<int>, vec_t&>::value, "");
-    static_assert(!std::is_constructible<span<int>, const vec_t&>::value, "");
-    static_assert(!std::is_constructible<span<int>, const deque_t&>::value, "");
-
-    static_assert(std::is_constructible<span<const int>, vec_t&>::value, "");
-    static_assert(std::is_constructible<span<const int>, const vec_t&>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<span<const int>, const deque_t&>::value, "");
-
-    static_assert(!std::is_constructible<span<int, 3>, vec_t&>::value, "");
-    static_assert(!std::is_constructible<span<int, 3>, const vec_t&>::value,
-                  "");
-    static_assert(!std::is_constructible<span<int, 3>, const deque_t&>::value,
-                  "");
-
-    static_assert(!std::is_constructible<span<const int, 3>, vec_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<const int, 3>, const vec_t&>::value, "");
-    static_assert(
-        !std::is_constructible<span<const int, 3>, const deque_t&>::value, "");
-
-    // vector<bool> is not contiguous and cannot be converted to span<bool>
-    // Regression test for https://github.com/tcbrindle/span/issues/24
-    static_assert(
-        !std::is_constructible<span<bool>, std::vector<bool>&>::value, "");
-    static_assert(!std::is_constructible<span<const bool>,
-                                         const std::vector<bool>&>::value, "");
-
-    //SECTION("non-const, dynamic size")
-    {
-        vec_t arr = {1, 2, 3};
-        span<int> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        vec_t arr = {1, 2, 3};
-        span<int const> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("non-const, static size")
-    {
-        std::array<int, 3> arr = {1, 2, 3};
-        span<int, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-
-    //SECTION("const, dynamic size")
-    {
-        std::array<int, 3> arr = {1, 2, 3};
-        span<int const, 3> s{arr};
-        ASSERT_EQ(s.size(), 3u);
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.begin(), arr.data());
-        ASSERT_EQ(s.end(), arr.data() + 3);
-    }
-}
-
-TEST(Span, ConstructionFromSpansOfDifferentSize)
-{
-    using zero_span = span<int, 0>;
-    using zero_const_span = span<const int, 0>;
-    using big_span = span<int, 1000000>;
-    using big_const_span = span<const int, 1000000>;
-    using dynamic_span = span<int>;
-    using dynamic_const_span = span<const int>;
-
-    static_assert(std::is_trivially_copyable<zero_span>::value, "");
-    static_assert(std::is_trivially_move_constructible<zero_span>::value, "");
-    static_assert(!std::is_constructible<zero_span, zero_const_span>::value,
-                  "");
-    static_assert(!std::is_constructible<zero_span, big_span>::value, "");
-    static_assert(!std::is_constructible<zero_span, big_const_span>::value, "");
-    static_assert(!std::is_constructible<zero_span, dynamic_span>::value, "");
-    static_assert(!std::is_constructible<zero_span, dynamic_const_span>::value,
-                  "");
-
-    static_assert(
-        std::is_nothrow_constructible<zero_const_span, zero_span>::value, "");
-    static_assert(std::is_trivially_copyable<zero_const_span>::value, "");
-    static_assert(std::is_trivially_move_constructible<zero_const_span>::value,
-                  "");
-    static_assert(!std::is_constructible<zero_const_span, big_span>::value, "");
-    static_assert(
-        !std::is_constructible<zero_const_span, big_const_span>::value, "");
-    static_assert(!std::is_constructible<zero_const_span, dynamic_span>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<zero_const_span, dynamic_const_span>::value, "");
-
-    static_assert(!std::is_constructible<big_span, zero_span>::value, "");
-    static_assert(!std::is_constructible<big_span, zero_const_span>::value, "");
-    static_assert(std::is_trivially_copyable<big_span>::value, "");
-    static_assert(std::is_trivially_move_constructible<big_span>::value, "");
-    static_assert(!std::is_constructible<big_span, big_const_span>::value, "");
-    static_assert(!std::is_constructible<big_span, dynamic_span>::value, "");
-    static_assert(!std::is_constructible<big_span, dynamic_const_span>::value,
-                  "");
-
-    static_assert(!std::is_constructible<big_const_span, zero_span>::value, "");
-    static_assert(
-        !std::is_constructible<big_const_span, zero_const_span>::value, "");
-    static_assert(std::is_trivially_copyable<big_const_span>::value, "");
-    static_assert(std::is_trivially_move_constructible<big_const_span>::value,
-                  "");
-    static_assert(
-        std::is_nothrow_constructible<big_const_span, big_span>::value, "");
-    static_assert(!std::is_constructible<big_const_span, dynamic_span>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<big_const_span, dynamic_const_span>::value, "");
-
-    static_assert(std::is_nothrow_constructible<dynamic_span, zero_span>::value,
-                  "");
-    static_assert(!std::is_constructible<dynamic_span, zero_const_span>::value,
-                  "");
-    static_assert(std::is_nothrow_constructible<dynamic_span, big_span>::value,
-                  "");
-    static_assert(!std::is_constructible<dynamic_span, big_const_span>::value,
-                  "");
-    static_assert(std::is_trivially_copyable<dynamic_span>::value, "");
-    static_assert(std::is_trivially_move_constructible<dynamic_span>::value,
-                  "");
-    static_assert(
-        !std::is_constructible<dynamic_span, dynamic_const_span>::value, "");
-
-    static_assert(
-        std::is_nothrow_constructible<dynamic_const_span, zero_span>::value,
-        "");
-    static_assert(std::is_nothrow_constructible<dynamic_const_span,
-                                                zero_const_span>::value,
-                  "");
-    static_assert(
-        std::is_nothrow_constructible<dynamic_const_span, big_span>::value, "");
-    static_assert(std::is_nothrow_constructible<dynamic_const_span,
-                                                big_const_span>::value,
-                  "");
-    static_assert(
-        std::is_nothrow_constructible<dynamic_const_span, dynamic_span>::value,
-        "");
-    static_assert(std::is_trivially_copyable<dynamic_const_span>::value, "");
-    static_assert(
-        std::is_trivially_move_constructible<dynamic_const_span>::value, "");
-
-    constexpr zero_const_span s0{};
-    constexpr dynamic_const_span d{s0};
-
-    static_assert(d.size() == 0, "");
-    static_assert(d.data() == nullptr, "");
-#ifndef _MSC_VER
-    static_assert(d.begin() == d.end(), "");
-#else
-    ASSERT_EQ(d.begin(), d.end());
-#endif
-}
-
-TEST(Span, MemberSubviewOperations)
-{
-    //SECTION("first<N>")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto f = s.first<3>();
-
-        static_assert(std::is_same<decltype(f), span<int, 3>>::value, "");
-        ASSERT_EQ(f.size(), 3u);
-        ASSERT_EQ(f.data(), arr);
-        ASSERT_EQ(f.begin(), arr);
-        ASSERT_EQ(f.end(), arr + 3);
-    }
-
-    //SECTION("last<N>")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto l = s.last<3>();
-
-        static_assert(std::is_same<decltype(l), span<int, 3>>::value, "");
-        ASSERT_EQ(l.size(), 3u);
-        ASSERT_EQ(l.data(), arr + 2);
-        ASSERT_EQ(l.begin(), arr + 2);
-        ASSERT_EQ(l.end(), std::end(arr));
-    }
-
-    //SECTION("subspan<N>")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto ss = s.subspan<1, 2>();
-
-        static_assert(std::is_same<decltype(ss), span<int, 2>>::value, "");
-        ASSERT_EQ(ss.size(), 2u);
-        ASSERT_EQ(ss.data(), arr + 1);
-        ASSERT_EQ(ss.begin(), arr + 1);
-        ASSERT_EQ(ss.end(), arr + 1 + 2);
-    }
-
-    //SECTION("first(n)")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto f = s.first(3);
-
-        static_assert(std::is_same<decltype(f), span<int>>::value, "");
-        ASSERT_EQ(f.size(), 3u);
-        ASSERT_EQ(f.data(), arr);
-        ASSERT_EQ(f.begin(), arr);
-        ASSERT_EQ(f.end(), arr + 3);
-    }
-
-    //SECTION("last(n)")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto l = s.last(3);
-
-        static_assert(std::is_same<decltype(l), span<int>>::value, "");
-        ASSERT_EQ(l.size(), 3u);
-        ASSERT_EQ(l.data(), arr + 2);
-        ASSERT_EQ(l.begin(), arr + 2);
-        ASSERT_EQ(l.end(), std::end(arr));
-    }
-
-    //SECTION("subspan(n)")
-    {
-        int arr[] = {1, 2, 3, 4, 5};
-        span<int, 5> s{arr};
-        auto ss = s.subspan(1, 2);
-
-        static_assert(std::is_same<decltype(ss), span<int>>::value, "");
-        ASSERT_EQ(ss.size(), 2u);
-        ASSERT_EQ(ss.data(), arr + 1);
-        ASSERT_EQ(ss.begin(), arr + 1);
-        ASSERT_EQ(ss.end(), arr + 1 + 2);
-    }
-
-    // TODO: Test all the dynamic subspan possibilities
-}
-
-TEST(Span, Observers)
-{
-    // We already use this everywhere, but whatever
-    constexpr span<int, 0> empty{};
-    static_assert(empty.size() == 0, "");
-    static_assert(empty.empty(), "");
-
-    constexpr int arr[] = {1, 2, 3};
-    static_assert(span<const int>{arr}.size() == 3, "");
-    static_assert(!span<const int>{arr}.empty(), "");
-}
-
-TEST(Span, ElementAccess)
-{
-    constexpr int arr[] = {1, 2, 3};
-    span<const int> s{arr};
-
-    ASSERT_EQ(s[0], arr[0]);
-    ASSERT_EQ(s[1], arr[1]);
-    ASSERT_EQ(s[2], arr[2]);
-}
-
-TEST(Span, IteratorSupport)
-{
-    {
-        std::vector<int> vec;
-        span<int> s{vec};
-        std::sort(s.begin(), s.end());
-        ASSERT_TRUE(std::is_sorted(vec.cbegin(), vec.cend()));
-    }
-
-    {
-        const std::vector<int> vec{1, 2, 3};
-        span<const int> s{vec};
-        ASSERT_TRUE(std::equal(s.rbegin(), s.rend(), vec.crbegin()));
-    }
-}
-
-TEST(Span, MakeSpan)
-{
-    {
-        int arr[3] = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<int, 3>>::value, "");
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.size(), 3u);
-    }
-
-    {
-        const int arr[3] = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<const int, 3>>::value, "");
-        ASSERT_EQ(s.data(), arr);
-        ASSERT_EQ(s.size(), 3u);
-    }
-
-    {
-        std::array<int, 3> arr = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<int, 3>>::value, "");
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.size(), arr.size());
-    }
-
-    {
-        const std::array<int, 3> arr = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<const int, 3>>::value, "");
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.size(), 3u);
-    }
-
-    {
-        std::vector<int> arr = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<int>>::value, "");
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.size(), arr.size());
-    }
-
-    {
-        const std::vector<int> arr = {1, 2, 3};
-        auto s = wpi::span(arr);
-        static_assert(std::is_same<decltype(s), span<const int>>::value, "");
-        ASSERT_EQ(s.data(), arr.data());
-        ASSERT_EQ(s.size(), arr.size());
-    }
-}
diff --git a/wpiutil/src/test/native/cpp/span/test_structured_bindings.cpp b/wpiutil/src/test/native/cpp/span/test_structured_bindings.cpp
deleted file mode 100644
index 5ce2969..0000000
--- a/wpiutil/src/test/native/cpp/span/test_structured_bindings.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-
-#include "wpi/span.h"
-
-#include "gtest/gtest.h"
-
-using static_span_t = wpi::span<int, 3>;
-using dynamic_span_t = wpi::span<int>;
-
-static_assert(std::tuple_size_v<static_span_t> == static_span_t::extent);
-static_assert(!wpi::detail::is_complete<std::tuple_size<dynamic_span_t>>::value);
-
-TEST(StructuredBindings, Test)
-{
-    // C++, why you no let me do constexpr structured bindings?
-
-    int arr[] = {1, 2, 3};
-
-    auto& [a1, a2, a3] = arr;
-    auto&& [s1, s2, s3] = wpi::span(arr);
-
-    ASSERT_EQ(a1, s1);
-    ASSERT_EQ(a2, s2);
-    ASSERT_EQ(a3, s3);
-
-    a1 = 99;
-    ASSERT_EQ(s1, 99);
-
-    s2 = 100;
-    ASSERT_EQ(a2, 100);
-}
diff --git a/wpiutil/src/test/native/cpp/uv/UvAsyncFunctionTest.cpp b/wpiutil/src/test/native/cpp/uv/UvAsyncFunctionTest.cpp
deleted file mode 100644
index 8407935..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvAsyncFunctionTest.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/AsyncFunction.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include <thread>
-
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Prepare.h"
-
-namespace wpi::uv {
-
-TEST(UvAsyncFunctionTest, Basic) {
-  int prepare_cb_called = 0;
-  int async_cb_called[2] = {0, 0};
-  int close_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = AsyncFunction<int(int)>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  loop->error.connect([](Error) { FAIL(); });
-
-  prepare->error.connect([](Error) { FAIL(); });
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      auto call0 = async->Call(0);
-      auto call1 = async->Call(1);
-      ASSERT_EQ(call0.get(), 1);
-      ASSERT_EQ(call1.get(), 2);
-    });
-  });
-  prepare->Start();
-
-  async->error.connect([](Error) { FAIL(); });
-  async->closed.connect([&] { close_cb_called++; });
-  async->wakeup = [&](promise<int> out, int v) {
-    ++async_cb_called[v];
-    if (v == 1) {
-      async->Close();
-      prepare->Close();
-    }
-    out.set_value(v + 1);
-  };
-
-  loop->Run();
-
-  ASSERT_EQ(async_cb_called[0], 1);
-  ASSERT_EQ(async_cb_called[1], 1);
-  ASSERT_EQ(close_cb_called, 1);
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, Ref) {
-  int prepare_cb_called = 0;
-  int val = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = AsyncFunction<int(int, int&)>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] { ASSERT_EQ(async->Call(1, val).get(), 2); });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<int> out, int v, int& r) {
-    r = v;
-    async->Close();
-    prepare->Close();
-    out.set_value(v + 1);
-  };
-
-  loop->Run();
-
-  ASSERT_EQ(val, 1);
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, Movable) {
-  int prepare_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async =
-      AsyncFunction<std::unique_ptr<int>(std::unique_ptr<int>)>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      auto val = std::make_unique<int>(1);
-      auto val2 = async->Call(std::move(val)).get();
-      ASSERT_NE(val2, nullptr);
-      ASSERT_EQ(*val2, 1);
-    });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<std::unique_ptr<int>> out,
-                      std::unique_ptr<int> v) {
-    async->Close();
-    prepare->Close();
-    out.set_value(std::move(v));
-  };
-
-  loop->Run();
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, CallIgnoreResult) {
-  int prepare_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async =
-      AsyncFunction<std::unique_ptr<int>(std::unique_ptr<int>)>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] { async->Call(std::make_unique<int>(1)); });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<std::unique_ptr<int>> out,
-                      std::unique_ptr<int> v) {
-    async->Close();
-    prepare->Close();
-    out.set_value(std::move(v));
-  };
-
-  loop->Run();
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, VoidCall) {
-  int prepare_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = AsyncFunction<void()>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] { async->Call(); });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<void> out) {
-    async->Close();
-    prepare->Close();
-    out.set_value();
-  };
-
-  loop->Run();
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, WaitFor) {
-  int prepare_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = AsyncFunction<int()>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      ASSERT_FALSE(async->Call().wait_for(std::chrono::milliseconds(10)));
-    });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<int> out) {
-    async->Close();
-    prepare->Close();
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    out.set_value(1);
-  };
-
-  loop->Run();
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncFunctionTest, VoidWaitFor) {
-  int prepare_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = AsyncFunction<void()>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      ASSERT_FALSE(async->Call().wait_for(std::chrono::milliseconds(10)));
-    });
-  });
-  prepare->Start();
-
-  async->wakeup = [&](promise<void> out) {
-    async->Close();
-    prepare->Close();
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    out.set_value();
-  };
-
-  loop->Run();
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvAsyncTest.cpp b/wpiutil/src/test/native/cpp/uv/UvAsyncTest.cpp
deleted file mode 100644
index 5561f1e..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvAsyncTest.cpp
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "wpi/uv/Async.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include <atomic>
-#include <thread>
-
-#include "wpi/mutex.h"
-#include "wpi/uv/Loop.h"
-#include "wpi/uv/Prepare.h"
-
-namespace wpi::uv {
-
-TEST(UvAsyncTest, CallbackOnly) {
-  std::atomic_int async_cb_called{0};
-  int prepare_cb_called = 0;
-  int close_cb_called = 0;
-
-  wpi::mutex mutex;
-  mutex.lock();
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = Async<>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  loop->error.connect([](Error) { FAIL(); });
-
-  prepare->error.connect([](Error) { FAIL(); });
-  prepare->closed.connect([&] { close_cb_called++; });
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      for (;;) {
-        mutex.lock();
-        int n = async_cb_called;
-        mutex.unlock();
-
-        if (n == 3) {
-          break;
-        }
-
-        async->Send();
-
-        std::this_thread::yield();
-      }
-    });
-    mutex.unlock();
-  });
-  prepare->Start();
-
-  async->error.connect([](Error) { FAIL(); });
-  async->closed.connect([&] { close_cb_called++; });
-  async->wakeup.connect([&] {
-    mutex.lock();
-    int n = ++async_cb_called;
-    mutex.unlock();
-
-    if (n == 3) {
-      async->Close();
-      prepare->Close();
-    }
-  });
-
-  loop->Run();
-
-  ASSERT_GT(prepare_cb_called, 0);
-  ASSERT_EQ(async_cb_called, 3);
-  ASSERT_EQ(close_cb_called, 2);
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncTest, Data) {
-  int prepare_cb_called = 0;
-  int async_cb_called[2] = {0, 0};
-  int close_cb_called = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = Async<int, std::function<void(int)>>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  loop->error.connect([](Error) { FAIL(); });
-
-  prepare->error.connect([](Error) { FAIL(); });
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] {
-      async->Send(0, [&](int v) {
-        ASSERT_EQ(v, 0);
-        ++async_cb_called[0];
-      });
-      async->Send(1, [&](int v) {
-        ASSERT_EQ(v, 1);
-        ++async_cb_called[1];
-        async->Close();
-        prepare->Close();
-      });
-    });
-  });
-  prepare->Start();
-
-  async->error.connect([](Error) { FAIL(); });
-  async->closed.connect([&] { close_cb_called++; });
-  async->wakeup.connect([&](int v, std::function<void(int)> f) { f(v); });
-
-  loop->Run();
-
-  ASSERT_EQ(async_cb_called[0], 1);
-  ASSERT_EQ(async_cb_called[1], 1);
-  ASSERT_EQ(close_cb_called, 1);
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-TEST(UvAsyncTest, DataRef) {
-  int prepare_cb_called = 0;
-  int val = 0;
-
-  std::thread theThread;
-
-  auto loop = Loop::Create();
-  auto async = Async<int, int&>::Create(loop);
-  auto prepare = Prepare::Create(loop);
-
-  prepare->prepare.connect([&] {
-    if (prepare_cb_called++) {
-      return;
-    }
-    theThread = std::thread([&] { async->Send(1, val); });
-  });
-  prepare->Start();
-
-  async->wakeup.connect([&](int v, int& r) {
-    r = v;
-    async->Close();
-    prepare->Close();
-  });
-
-  loop->Run();
-
-  ASSERT_EQ(val, 1);
-
-  if (theThread.joinable()) {
-    theThread.join();
-  }
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvBufferTest.cpp b/wpiutil/src/test/native/cpp/uv/UvBufferTest.cpp
deleted file mode 100644
index e262181..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvBufferTest.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Buffer.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-namespace wpi::uv {
-
-TEST(UvSimpleBufferPoolTest, ConstructDefault) {
-  SimpleBufferPool<> pool;
-  auto buf1 = pool.Allocate();
-  ASSERT_EQ(buf1.len, 4096u);  // NOLINT
-  pool.Release({&buf1, 1});
-}
-
-TEST(UvSimpleBufferPoolTest, ConstructSize) {
-  SimpleBufferPool<4> pool{8192};
-  auto buf1 = pool.Allocate();
-  ASSERT_EQ(buf1.len, 8192u);  // NOLINT
-  pool.Release({&buf1, 1});
-}
-
-TEST(UvSimpleBufferPoolTest, ReleaseReuse) {
-  SimpleBufferPool<4> pool;
-  auto buf1 = pool.Allocate();
-  auto buf1copy = buf1;
-  auto origSize = buf1.len;
-  buf1.len = 8;
-  pool.Release({&buf1, 1});
-  ASSERT_EQ(buf1.base, nullptr);
-  auto buf2 = pool.Allocate();
-  ASSERT_EQ(buf1copy.base, buf2.base);
-  ASSERT_EQ(buf2.len, origSize);
-  pool.Release({&buf2, 1});
-}
-
-TEST(UvSimpleBufferPoolTest, ClearRemaining) {
-  SimpleBufferPool<4> pool;
-  auto buf1 = pool.Allocate();
-  pool.Release({&buf1, 1});
-  ASSERT_EQ(pool.Remaining(), 1u);
-  pool.Clear();
-  ASSERT_EQ(pool.Remaining(), 0u);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvGetAddrInfoTest.cpp b/wpiutil/src/test/native/cpp/uv/UvGetAddrInfoTest.cpp
deleted file mode 100644
index b397e24..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvGetAddrInfoTest.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "wpi/uv/GetAddrInfo.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include "wpi/uv/Loop.h"
-
-#define CONCURRENT_COUNT 10
-
-namespace wpi::uv {
-
-TEST(UvGetAddrInfoTest, BothNull) {
-  int fail_cb_called = 0;
-
-  auto loop = Loop::Create();
-  loop->error.connect([&](Error err) {
-    ASSERT_EQ(err.code(), UV_EINVAL);
-    fail_cb_called++;
-  });
-
-  GetAddrInfo(
-      loop, [](const addrinfo&) { FAIL(); }, "");
-  loop->Run();
-  ASSERT_EQ(fail_cb_called, 1);
-}
-
-TEST(UvGetAddrInfoTest, FailedLookup) {
-  int fail_cb_called = 0;
-
-  auto loop = Loop::Create();
-  loop->error.connect([&](Error err) {
-    ASSERT_EQ(fail_cb_called, 0);
-    ASSERT_LT(err.code(), 0);
-    fail_cb_called++;
-  });
-
-  // Use a FQDN by ending in a period
-  GetAddrInfo(
-      loop, [](const addrinfo&) { FAIL(); }, "xyzzy.xyzzy.xyzzy.");
-  loop->Run();
-  ASSERT_EQ(fail_cb_called, 1);
-}
-
-TEST(UvGetAddrInfoTest, Basic) {
-  int getaddrinfo_cbs = 0;
-
-  auto loop = Loop::Create();
-  loop->error.connect([](Error) { FAIL(); });
-
-  GetAddrInfo(
-      loop, [&](const addrinfo&) { getaddrinfo_cbs++; }, "localhost");
-
-  loop->Run();
-
-  ASSERT_EQ(getaddrinfo_cbs, 1);
-}
-
-#ifndef _WIN32
-TEST(UvGetAddrInfoTest, Concurrent) {
-  int getaddrinfo_cbs = 0;
-  int callback_counts[CONCURRENT_COUNT];
-
-  auto loop = Loop::Create();
-  loop->error.connect([](Error) { FAIL(); });
-
-  for (int i = 0; i < CONCURRENT_COUNT; i++) {
-    callback_counts[i] = 0;
-    GetAddrInfo(
-        loop,
-        [i, &callback_counts, &getaddrinfo_cbs](const addrinfo&) {
-          callback_counts[i]++;
-          getaddrinfo_cbs++;
-        },
-        "localhost");
-  }
-
-  loop->Run();
-
-  for (int i = 0; i < CONCURRENT_COUNT; i++) {
-    ASSERT_EQ(callback_counts[i], 1);
-  }
-}
-#endif
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvGetNameInfoTest.cpp b/wpiutil/src/test/native/cpp/uv/UvGetNameInfoTest.cpp
deleted file mode 100644
index db1eefe..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvGetNameInfoTest.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "wpi/uv/GetNameInfo.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include "wpi/uv/Loop.h"
-
-namespace wpi::uv {
-
-TEST(UvGetNameInfoTest, BasicIp4) {
-  int getnameinfo_cbs = 0;
-
-  auto loop = Loop::Create();
-  loop->error.connect([](Error) { FAIL(); });
-
-  GetNameInfo4(
-      loop,
-      [&](const char* hostname, const char* service) {
-        ASSERT_NE(hostname, nullptr);
-        ASSERT_NE(service, nullptr);
-        getnameinfo_cbs++;
-      },
-      "127.0.0.1", 80);
-
-  loop->Run();
-
-  ASSERT_EQ(getnameinfo_cbs, 1);
-}
-
-TEST(UvGetNameInfoTest, BasicIp6) {
-  int getnameinfo_cbs = 0;
-
-  auto loop = Loop::Create();
-  loop->error.connect([](Error) { FAIL(); });
-
-  GetNameInfo6(
-      loop,
-      [&](const char* hostname, const char* service) {
-        ASSERT_NE(hostname, nullptr);
-        ASSERT_NE(service, nullptr);
-        getnameinfo_cbs++;
-      },
-      "::1", 80);
-
-  loop->Run();
-
-  ASSERT_EQ(getnameinfo_cbs, 1);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvLoopWalkTest.cpp b/wpiutil/src/test/native/cpp/uv/UvLoopWalkTest.cpp
deleted file mode 100644
index 38a3342..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvLoopWalkTest.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * 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 "wpi/uv/Loop.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"  // NOLINT(build/include_order)
-
-#include "wpi/uv/Timer.h"
-
-namespace wpi::uv {
-
-TEST(UvLoopTest, Walk) {
-  int seen_timer_handle = 0;
-
-  auto loop = Loop::Create();
-  auto timer = Timer::Create(loop);
-
-  loop->error.connect([](Error) { FAIL(); });
-
-  timer->error.connect([](Error) { FAIL(); });
-
-  timer->timeout.connect([&, theTimer = timer.get()] {
-    theTimer->GetLoopRef().Walk([&](Handle& it) {
-      if (&it == timer.get()) {
-        seen_timer_handle++;
-      }
-    });
-    theTimer->Close();
-  });
-  timer->Start(Timer::Time{1});
-
-  // Start event loop, expect to see the timer handle
-  ASSERT_EQ(seen_timer_handle, 0);
-  loop->Run();
-  ASSERT_EQ(seen_timer_handle, 1);
-
-  // Loop is finished, should not see our timer handle
-  seen_timer_handle = 0;
-  loop->Walk([&](Handle& it) {
-    if (&it == timer.get()) {
-      seen_timer_handle++;
-    }
-  });
-  ASSERT_EQ(seen_timer_handle, 0);
-}
-
-}  // namespace wpi::uv
diff --git a/wpiutil/src/test/native/cpp/uv/UvTimerTest.cpp b/wpiutil/src/test/native/cpp/uv/UvTimerTest.cpp
deleted file mode 100644
index 1a6258f..0000000
--- a/wpiutil/src/test/native/cpp/uv/UvTimerTest.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "wpi/uv/Timer.h"  // NOLINT(build/include_order)
-
-#include "gtest/gtest.h"
-
-namespace wpi::uv {
-
-TEST(UvTimerTest, StartAndStop) {
-  auto loop = Loop::Create();
-  auto handleNoRepeat = Timer::Create(loop);
-  auto handleRepeat = Timer::Create(loop);
-
-  bool checkTimerNoRepeatEvent = false;
-  bool checkTimerRepeatEvent = false;
-
-  handleNoRepeat->error.connect([](Error) { FAIL(); });
-  handleRepeat->error.connect([](Error) { FAIL(); });
-
-  handleNoRepeat->timeout.connect(
-      [&checkTimerNoRepeatEvent, handle = handleNoRepeat.get()] {
-        ASSERT_FALSE(checkTimerNoRepeatEvent);
-        checkTimerNoRepeatEvent = true;
-        handle->Stop();
-        handle->Close();
-        ASSERT_TRUE(handle->IsClosing());
-      });
-
-  handleRepeat->timeout.connect(
-      [&checkTimerRepeatEvent, handle = handleRepeat.get()] {
-        if (checkTimerRepeatEvent) {
-          handle->Stop();
-          handle->Close();
-          ASSERT_TRUE(handle->IsClosing());
-        } else {
-          checkTimerRepeatEvent = true;
-          ASSERT_FALSE(handle->IsClosing());
-        }
-      });
-
-  handleNoRepeat->Start(Timer::Time{0}, Timer::Time{0});
-  handleRepeat->Start(Timer::Time{0}, Timer::Time{1});
-
-  ASSERT_TRUE(handleNoRepeat->IsActive());
-  ASSERT_FALSE(handleNoRepeat->IsClosing());
-
-  ASSERT_TRUE(handleRepeat->IsActive());
-  ASSERT_FALSE(handleRepeat->IsClosing());
-
-  loop->Run();
-
-  ASSERT_TRUE(checkTimerNoRepeatEvent);
-  ASSERT_TRUE(checkTimerRepeatEvent);
-}
-
-TEST(UvTimerTest, Repeat) {
-  auto loop = Loop::Create();
-  auto handle = Timer::Create(loop);
-
-  handle->SetRepeat(Timer::Time{42});
-  ASSERT_EQ(handle->GetRepeat(), Timer::Time{42});
-  handle->Close();
-
-  loop->Run();  // forces close callback to run
-}
-
-}  // namespace wpi::uv